+990 -24

Cargo.lock

··· 13 13 ] 14 14 15 15 [[package]] 16 16 + name = "ab_glyph" 17 17 + version = "0.2.32" 18 18 + source = "registry+https://github.com/rust-lang/crates.io-index" 19 19 + checksum = "01c0457472c38ea5bd1c3b5ada5e368271cb550be7a4ca4a0b4634e9913f6cc2" 20 20 + dependencies = [ 21 21 + "ab_glyph_rasterizer", 22 22 + "owned_ttf_parser", 23 23 + ] 24 24 + 25 25 + [[package]] 26 26 + name = "ab_glyph_rasterizer" 27 27 + version = "0.1.10" 28 28 + source = "registry+https://github.com/rust-lang/crates.io-index" 29 29 + checksum = "366ffbaa4442f4684d91e2cd7c5ea7c4ed8add41959a31447066e279e432b618" 30 30 + 31 31 + [[package]] 16 32 name = "actix" 17 33 version = "0.13.5" 18 34 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 416 432 checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f" 417 433 418 434 [[package]] 435 435 + name = "android-activity" 436 436 + version = "0.6.0" 437 437 + source = "registry+https://github.com/rust-lang/crates.io-index" 438 438 + checksum = "ef6978589202a00cd7e118380c448a08b6ed394c3a8df3a430d0898e3a42d046" 439 439 + dependencies = [ 440 440 + "android-properties", 441 441 + "bitflags 2.6.0", 442 442 + "cc", 443 443 + "cesu8", 444 444 + "jni", 445 445 + "jni-sys", 446 446 + "libc", 447 447 + "log", 448 448 + "ndk", 449 449 + "ndk-context", 450 450 + "ndk-sys 0.6.0+11769913", 451 451 + "num_enum", 452 452 + "thiserror 1.0.63", 453 453 + ] 454 454 + 455 455 + [[package]] 456 456 + name = "android-properties" 457 457 + version = "0.2.2" 458 458 + source = "registry+https://github.com/rust-lang/crates.io-index" 459 459 + checksum = "fc7eb209b1518d6bb87b283c20095f5228ecda460da70b44f0802523dea6da04" 460 460 + 461 461 + [[package]] 419 462 name = "android-tzdata" 420 463 version = "0.1.1" 421 464 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 512 555 ] 513 556 514 557 [[package]] 558 558 + name = "arrayref" 559 559 + version = "0.3.9" 560 560 + source = "registry+https://github.com/rust-lang/crates.io-index" 561 561 + checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb" 562 562 + 563 563 + [[package]] 515 564 name = "arrayvec" 516 565 version = "0.7.6" 517 566 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 519 568 dependencies = [ 520 569 "serde", 521 570 ] 571 571 + 572 572 + [[package]] 573 573 + name = "as-raw-xcb-connection" 574 574 + version = "1.0.1" 575 575 + source = "registry+https://github.com/rust-lang/crates.io-index" 576 576 + checksum = "175571dd1d178ced59193a6fc02dde1b972eb0bc56c892cde9beeceac5bf0f6b" 522 577 523 578 [[package]] 524 579 name = "ascii_utils" ··· 791 846 "futures-lite", 792 847 "parking", 793 848 "polling 3.7.3", 794 794 - "rustix", 849 849 + "rustix 0.38.42", 795 850 "slab", 796 851 "tracing", 797 852 "windows-sys 0.59.0", ··· 823 878 "cfg-if 1.0.0", 824 879 "event-listener 5.3.1", 825 880 "futures-lite", 826 826 - "rustix", 881 881 + "rustix 0.38.42", 827 882 "tracing", 828 883 ] 829 884 ··· 850 905 "cfg-if 1.0.0", 851 906 "futures-core", 852 907 "futures-io", 853 853 - "rustix", 908 908 + "rustix 0.38.42", 854 909 "signal-hook-registry", 855 910 "slab", 856 911 "windows-sys 0.59.0", ··· 1286 1341 ] 1287 1342 1288 1343 [[package]] 1344 1344 + name = "block2" 1345 1345 + version = "0.5.1" 1346 1346 + source = "registry+https://github.com/rust-lang/crates.io-index" 1347 1347 + checksum = "2c132eebf10f5cad5289222520a4a058514204aed6d791f1cf4fe8088b82d15f" 1348 1348 + dependencies = [ 1349 1349 + "objc2", 1350 1350 + ] 1351 1351 + 1352 1352 + [[package]] 1289 1353 name = "blocking" 1290 1354 version = "1.6.1" 1291 1355 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1418 1482 "glib-sys", 1419 1483 "libc", 1420 1484 "system-deps 7.0.3", 1485 1485 + ] 1486 1486 + 1487 1487 + [[package]] 1488 1488 + name = "calloop" 1489 1489 + version = "0.13.0" 1490 1490 + source = "registry+https://github.com/rust-lang/crates.io-index" 1491 1491 + checksum = "b99da2f8558ca23c71f4fd15dc57c906239752dd27ff3c00a1d56b685b7cbfec" 1492 1492 + dependencies = [ 1493 1493 + "bitflags 2.6.0", 1494 1494 + "log", 1495 1495 + "polling 3.7.3", 1496 1496 + "rustix 0.38.42", 1497 1497 + "slab", 1498 1498 + "thiserror 1.0.63", 1499 1499 + ] 1500 1500 + 1501 1501 + [[package]] 1502 1502 + name = "calloop-wayland-source" 1503 1503 + version = "0.3.0" 1504 1504 + source = "registry+https://github.com/rust-lang/crates.io-index" 1505 1505 + checksum = "95a66a987056935f7efce4ab5668920b5d0dac4a7c99991a67395f13702ddd20" 1506 1506 + dependencies = [ 1507 1507 + "calloop", 1508 1508 + "rustix 0.38.42", 1509 1509 + "wayland-backend", 1510 1510 + "wayland-client", 1421 1511 ] 1422 1512 1423 1513 [[package]] ··· 1481 1571 checksum = "4f4c707c6a209cbe82d10abd08e1ea8995e9ea937d2550646e02798948992be0" 1482 1572 1483 1573 [[package]] 1574 1574 + name = "cesu8" 1575 1575 + version = "1.1.0" 1576 1576 + source = "registry+https://github.com/rust-lang/crates.io-index" 1577 1577 + checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c" 1578 1578 + 1579 1579 + [[package]] 1484 1580 name = "cexpr" 1485 1581 version = "0.6.0" 1486 1582 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1675 1771 ] 1676 1772 1677 1773 [[package]] 1774 1774 + name = "cocoa" 1775 1775 + version = "0.24.1" 1776 1776 + source = "registry+https://github.com/rust-lang/crates.io-index" 1777 1777 + checksum = "f425db7937052c684daec3bd6375c8abe2d146dca4b8b143d6db777c39138f3a" 1778 1778 + dependencies = [ 1779 1779 + "bitflags 1.3.2", 1780 1780 + "block", 1781 1781 + "cocoa-foundation", 1782 1782 + "core-foundation", 1783 1783 + "core-graphics 0.22.3", 1784 1784 + "foreign-types 0.3.2", 1785 1785 + "libc", 1786 1786 + "objc", 1787 1787 + ] 1788 1788 + 1789 1789 + [[package]] 1790 1790 + name = "cocoa-foundation" 1791 1791 + version = "0.1.2" 1792 1792 + source = "registry+https://github.com/rust-lang/crates.io-index" 1793 1793 + checksum = "8c6234cbb2e4c785b456c0644748b1ac416dd045799740356f8363dfe00c93f7" 1794 1794 + dependencies = [ 1795 1795 + "bitflags 1.3.2", 1796 1796 + "block", 1797 1797 + "core-foundation", 1798 1798 + "core-graphics-types", 1799 1799 + "libc", 1800 1800 + "objc", 1801 1801 + ] 1802 1802 + 1803 1803 + [[package]] 1678 1804 name = "codespan-reporting" 1679 1805 version = "0.11.1" 1680 1806 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1716 1842 version = "1.0.2" 1717 1843 source = "registry+https://github.com/rust-lang/crates.io-index" 1718 1844 checksum = "d3fd119d74b830634cea2a0f58bbd0d54540518a14397557951e79340abc28c0" 1845 1845 + 1846 1846 + [[package]] 1847 1847 + name = "combine" 1848 1848 + version = "4.6.7" 1849 1849 + source = "registry+https://github.com/rust-lang/crates.io-index" 1850 1850 + checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd" 1851 1851 + dependencies = [ 1852 1852 + "bytes", 1853 1853 + "memchr", 1854 1854 + ] 1719 1855 1720 1856 [[package]] 1721 1857 name = "compact_str" ··· 1813 1949 checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" 1814 1950 1815 1951 [[package]] 1952 1952 + name = "core-graphics" 1953 1953 + version = "0.22.3" 1954 1954 + source = "registry+https://github.com/rust-lang/crates.io-index" 1955 1955 + checksum = "2581bbab3b8ffc6fcbd550bf46c355135d16e9ff2a6ea032ad6b9bf1d7efe4fb" 1956 1956 + dependencies = [ 1957 1957 + "bitflags 1.3.2", 1958 1958 + "core-foundation", 1959 1959 + "core-graphics-types", 1960 1960 + "foreign-types 0.3.2", 1961 1961 + "libc", 1962 1962 + ] 1963 1963 + 1964 1964 + [[package]] 1965 1965 + name = "core-graphics" 1966 1966 + version = "0.23.2" 1967 1967 + source = "registry+https://github.com/rust-lang/crates.io-index" 1968 1968 + checksum = "c07782be35f9e1140080c6b96f0d44b739e2278479f64e02fdab4e32dfd8b081" 1969 1969 + dependencies = [ 1970 1970 + "bitflags 1.3.2", 1971 1971 + "core-foundation", 1972 1972 + "core-graphics-types", 1973 1973 + "foreign-types 0.5.0", 1974 1974 + "libc", 1975 1975 + ] 1976 1976 + 1977 1977 + [[package]] 1816 1978 name = "core-graphics-types" 1817 1979 version = "0.1.3" 1818 1980 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1930 2092 "crossterm_winapi", 1931 2093 "mio 1.0.2", 1932 2094 "parking_lot", 1933 1933 - "rustix", 2095 2095 + "rustix 0.38.42", 1934 2096 "serde", 1935 2097 "signal-hook", 1936 2098 "signal-hook-mio", ··· 2026 2188 ] 2027 2189 2028 2190 [[package]] 2191 2191 + name = "cursor-icon" 2192 2192 + version = "1.2.0" 2193 2193 + source = "registry+https://github.com/rust-lang/crates.io-index" 2194 2194 + checksum = "f27ae1dd37df86211c42e150270f82743308803d90a6f6e6651cd730d5e1732f" 2195 2195 + 2196 2196 + [[package]] 2029 2197 name = "curve25519-dalek" 2030 2198 version = "4.1.3" 2031 2199 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 2132 2300 "libc", 2133 2301 "libdbus-sys", 2134 2302 "winapi", 2303 2303 + ] 2304 2304 + 2305 2305 + [[package]] 2306 2306 + name = "dbus-crossroads" 2307 2307 + version = "0.5.3" 2308 2308 + source = "registry+https://github.com/rust-lang/crates.io-index" 2309 2309 + checksum = "64bff0bd181fba667660276c6b7ebdc50cff37ce593e7adf9e734f89c8f444e8" 2310 2310 + dependencies = [ 2311 2311 + "dbus", 2135 2312 ] 2136 2313 2137 2314 [[package]] ··· 3646 3823 "redox_users 0.5.0", 3647 3824 "windows-sys 0.59.0", 3648 3825 ] 3826 3826 + 3827 3827 + [[package]] 3828 3828 + name = "dispatch" 3829 3829 + version = "0.2.0" 3830 3830 + source = "registry+https://github.com/rust-lang/crates.io-index" 3831 3831 + checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b" 3649 3832 3650 3833 [[package]] 3651 3834 name = "displaydoc" ··· 3665 3848 checksum = "8c97b9233581d84b8e1e689cdd3a47b6f69770084fc246e86a7f78b0d9c1d4a5" 3666 3849 3667 3850 [[package]] 3851 3851 + name = "dlib" 3852 3852 + version = "0.5.2" 3853 3853 + source = "registry+https://github.com/rust-lang/crates.io-index" 3854 3854 + checksum = "330c60081dcc4c72131f8eb70510f1ac07223e5d4163db481a04a0befcffa412" 3855 3855 + dependencies = [ 3856 3856 + "libloading 0.8.5", 3857 3857 + ] 3858 3858 + 3859 3859 + [[package]] 3668 3860 name = "dlopen2" 3669 3861 version = "0.6.1" 3670 3862 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 3729 3921 version = "1.2.1" 3730 3922 source = "registry+https://github.com/rust-lang/crates.io-index" 3731 3923 checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2" 3924 3924 + 3925 3925 + [[package]] 3926 3926 + name = "dpi" 3927 3927 + version = "0.1.2" 3928 3928 + source = "registry+https://github.com/rust-lang/crates.io-index" 3929 3929 + checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76" 3732 3930 3733 3931 [[package]] 3734 3932 name = "dprint-core" ··· 4308 4506 checksum = "7e5768da2206272c81ef0b5e951a41862938a6070da63bcea197899942d3b947" 4309 4507 dependencies = [ 4310 4508 "cfg-if 1.0.0", 4311 4311 - "rustix", 4509 4509 + "rustix 0.38.42", 4312 4510 "windows-sys 0.52.0", 4313 4511 ] 4314 4512 ··· 4450 4648 4451 4649 [[package]] 4452 4650 name = "foreign-types" 4651 4651 + version = "0.3.2" 4652 4652 + source = "registry+https://github.com/rust-lang/crates.io-index" 4653 4653 + checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" 4654 4654 + dependencies = [ 4655 4655 + "foreign-types-shared 0.1.1", 4656 4656 + ] 4657 4657 + 4658 4658 + [[package]] 4659 4659 + name = "foreign-types" 4453 4660 version = "0.5.0" 4454 4661 source = "registry+https://github.com/rust-lang/crates.io-index" 4455 4662 checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965" 4456 4663 dependencies = [ 4457 4664 "foreign-types-macros", 4458 4458 - "foreign-types-shared", 4665 4665 + "foreign-types-shared 0.3.1", 4459 4666 ] 4460 4667 4461 4668 [[package]] ··· 4471 4678 4472 4679 [[package]] 4473 4680 name = "foreign-types-shared" 4681 4681 + version = "0.1.1" 4682 4682 + source = "registry+https://github.com/rust-lang/crates.io-index" 4683 4683 + checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" 4684 4684 + 4685 4685 + [[package]] 4686 4686 + name = "foreign-types-shared" 4474 4687 version = "0.3.1" 4475 4688 source = "registry+https://github.com/rust-lang/crates.io-index" 4476 4689 checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b" ··· 4518 4731 source = "registry+https://github.com/rust-lang/crates.io-index" 4519 4732 checksum = "f7e180ac76c23b45e767bd7ae9579bc0bb458618c4bc71835926e098e61d15f8" 4520 4733 dependencies = [ 4521 4521 - "rustix", 4734 4734 + "rustix 0.38.42", 4522 4735 "windows-sys 0.52.0", 4523 4736 ] 4524 4737 ··· 4732 4945 "typenum", 4733 4946 "version_check", 4734 4947 "zeroize", 4948 4948 + ] 4949 4949 + 4950 4950 + [[package]] 4951 4951 + name = "gethostname" 4952 4952 + version = "1.1.0" 4953 4953 + source = "registry+https://github.com/rust-lang/crates.io-index" 4954 4954 + checksum = "1bd49230192a3797a9a4d6abe9b3eed6f7fa4c8a8a4947977c6f80025f92cbd8" 4955 4955 + dependencies = [ 4956 4956 + "rustix 1.1.2", 4957 4957 + "windows-link", 4735 4958 ] 4736 4959 4737 4960 [[package]] ··· 6103 6326 checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674" 6104 6327 6105 6328 [[package]] 6329 6329 + name = "jni" 6330 6330 + version = "0.21.1" 6331 6331 + source = "registry+https://github.com/rust-lang/crates.io-index" 6332 6332 + checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97" 6333 6333 + dependencies = [ 6334 6334 + "cesu8", 6335 6335 + "cfg-if 1.0.0", 6336 6336 + "combine", 6337 6337 + "jni-sys", 6338 6338 + "log", 6339 6339 + "thiserror 1.0.63", 6340 6340 + "walkdir", 6341 6341 + "windows-sys 0.45.0", 6342 6342 + ] 6343 6343 + 6344 6344 + [[package]] 6106 6345 name = "jni-sys" 6107 6346 version = "0.3.0" 6108 6347 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 6317 6556 6318 6557 [[package]] 6319 6558 name = "libc" 6320 6320 - version = "0.2.169" 6559 6559 + version = "0.2.178" 6321 6560 source = "registry+https://github.com/rust-lang/crates.io-index" 6322 6322 - checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a" 6561 6561 + checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091" 6323 6562 6324 6563 [[package]] 6325 6564 name = "libdbus-sys" ··· 6412 6651 dependencies = [ 6413 6652 "bitflags 2.6.0", 6414 6653 "libc", 6415 6415 - "redox_syscall", 6654 6654 + "redox_syscall 0.5.3", 6416 6655 ] 6417 6656 6418 6657 [[package]] ··· 6469 6708 checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89" 6470 6709 6471 6710 [[package]] 6711 6711 + name = "linux-raw-sys" 6712 6712 + version = "0.11.0" 6713 6713 + source = "registry+https://github.com/rust-lang/crates.io-index" 6714 6714 + checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039" 6715 6715 + 6716 6716 + [[package]] 6472 6717 name = "litemap" 6473 6718 version = "0.7.4" 6474 6719 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 6759 7004 "bitflags 2.6.0", 6760 7005 "block", 6761 7006 "core-graphics-types", 6762 6762 - "foreign-types", 7007 7007 + "foreign-types 0.5.0", 6763 7008 "log", 6764 7009 "objc", 6765 7010 "paste", ··· 6974 7219 ] 6975 7220 6976 7221 [[package]] 7222 7222 + name = "ndk" 7223 7223 + version = "0.9.0" 7224 7224 + source = "registry+https://github.com/rust-lang/crates.io-index" 7225 7225 + checksum = "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4" 7226 7226 + dependencies = [ 7227 7227 + "bitflags 2.6.0", 7228 7228 + "jni-sys", 7229 7229 + "log", 7230 7230 + "ndk-sys 0.6.0+11769913", 7231 7231 + "num_enum", 7232 7232 + "raw-window-handle", 7233 7233 + "thiserror 1.0.63", 7234 7234 + ] 7235 7235 + 7236 7236 + [[package]] 7237 7237 + name = "ndk-context" 7238 7238 + version = "0.1.1" 7239 7239 + source = "registry+https://github.com/rust-lang/crates.io-index" 7240 7240 + checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b" 7241 7241 + 7242 7242 + [[package]] 6977 7243 name = "ndk-sys" 6978 7244 version = "0.5.0+25.2.9519653" 6979 7245 source = "registry+https://github.com/rust-lang/crates.io-index" 6980 7246 checksum = "8c196769dd60fd4f363e11d948139556a344e79d451aeb2fa2fd040738ef7691" 7247 7247 + dependencies = [ 7248 7248 + "jni-sys", 7249 7249 + ] 7250 7250 + 7251 7251 + [[package]] 7252 7252 + name = "ndk-sys" 7253 7253 + version = "0.6.0+11769913" 7254 7254 + source = "registry+https://github.com/rust-lang/crates.io-index" 7255 7255 + checksum = "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873" 6981 7256 dependencies = [ 6982 7257 "jni-sys", 6983 7258 ] ··· 7272 7547 ] 7273 7548 7274 7549 [[package]] 7550 7550 + name = "num_enum" 7551 7551 + version = "0.7.5" 7552 7552 + source = "registry+https://github.com/rust-lang/crates.io-index" 7553 7553 + checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c" 7554 7554 + dependencies = [ 7555 7555 + "num_enum_derive", 7556 7556 + "rustversion", 7557 7557 + ] 7558 7558 + 7559 7559 + [[package]] 7560 7560 + name = "num_enum_derive" 7561 7561 + version = "0.7.5" 7562 7562 + source = "registry+https://github.com/rust-lang/crates.io-index" 7563 7563 + checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7" 7564 7564 + dependencies = [ 7565 7565 + "proc-macro-crate", 7566 7566 + "proc-macro2", 7567 7567 + "quote", 7568 7568 + "syn 2.0.91", 7569 7569 + ] 7570 7570 + 7571 7571 + [[package]] 7275 7572 name = "num_threads" 7276 7573 version = "0.1.7" 7277 7574 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 7290 7587 ] 7291 7588 7292 7589 [[package]] 7590 7590 + name = "objc-sys" 7591 7591 + version = "0.3.5" 7592 7592 + source = "registry+https://github.com/rust-lang/crates.io-index" 7593 7593 + checksum = "cdb91bdd390c7ce1a8607f35f3ca7151b65afc0ff5ff3b34fa350f7d7c7e4310" 7594 7594 + 7595 7595 + [[package]] 7596 7596 + name = "objc2" 7597 7597 + version = "0.5.2" 7598 7598 + source = "registry+https://github.com/rust-lang/crates.io-index" 7599 7599 + checksum = "46a785d4eeff09c14c487497c162e92766fbb3e4059a71840cecc03d9a50b804" 7600 7600 + dependencies = [ 7601 7601 + "objc-sys", 7602 7602 + "objc2-encode", 7603 7603 + ] 7604 7604 + 7605 7605 + [[package]] 7606 7606 + name = "objc2-app-kit" 7607 7607 + version = "0.2.2" 7608 7608 + source = "registry+https://github.com/rust-lang/crates.io-index" 7609 7609 + checksum = "e4e89ad9e3d7d297152b17d39ed92cd50ca8063a89a9fa569046d41568891eff" 7610 7610 + dependencies = [ 7611 7611 + "bitflags 2.6.0", 7612 7612 + "block2", 7613 7613 + "libc", 7614 7614 + "objc2", 7615 7615 + "objc2-core-data", 7616 7616 + "objc2-core-image", 7617 7617 + "objc2-foundation", 7618 7618 + "objc2-quartz-core", 7619 7619 + ] 7620 7620 + 7621 7621 + [[package]] 7622 7622 + name = "objc2-cloud-kit" 7623 7623 + version = "0.2.2" 7624 7624 + source = "registry+https://github.com/rust-lang/crates.io-index" 7625 7625 + checksum = "74dd3b56391c7a0596a295029734d3c1c5e7e510a4cb30245f8221ccea96b009" 7626 7626 + dependencies = [ 7627 7627 + "bitflags 2.6.0", 7628 7628 + "block2", 7629 7629 + "objc2", 7630 7630 + "objc2-core-location", 7631 7631 + "objc2-foundation", 7632 7632 + ] 7633 7633 + 7634 7634 + [[package]] 7635 7635 + name = "objc2-contacts" 7636 7636 + version = "0.2.2" 7637 7637 + source = "registry+https://github.com/rust-lang/crates.io-index" 7638 7638 + checksum = "a5ff520e9c33812fd374d8deecef01d4a840e7b41862d849513de77e44aa4889" 7639 7639 + dependencies = [ 7640 7640 + "block2", 7641 7641 + "objc2", 7642 7642 + "objc2-foundation", 7643 7643 + ] 7644 7644 + 7645 7645 + [[package]] 7646 7646 + name = "objc2-core-data" 7647 7647 + version = "0.2.2" 7648 7648 + source = "registry+https://github.com/rust-lang/crates.io-index" 7649 7649 + checksum = "617fbf49e071c178c0b24c080767db52958f716d9eabdf0890523aeae54773ef" 7650 7650 + dependencies = [ 7651 7651 + "bitflags 2.6.0", 7652 7652 + "block2", 7653 7653 + "objc2", 7654 7654 + "objc2-foundation", 7655 7655 + ] 7656 7656 + 7657 7657 + [[package]] 7658 7658 + name = "objc2-core-image" 7659 7659 + version = "0.2.2" 7660 7660 + source = "registry+https://github.com/rust-lang/crates.io-index" 7661 7661 + checksum = "55260963a527c99f1819c4f8e3b47fe04f9650694ef348ffd2227e8196d34c80" 7662 7662 + dependencies = [ 7663 7663 + "block2", 7664 7664 + "objc2", 7665 7665 + "objc2-foundation", 7666 7666 + "objc2-metal", 7667 7667 + ] 7668 7668 + 7669 7669 + [[package]] 7670 7670 + name = "objc2-core-location" 7671 7671 + version = "0.2.2" 7672 7672 + source = "registry+https://github.com/rust-lang/crates.io-index" 7673 7673 + checksum = "000cfee34e683244f284252ee206a27953279d370e309649dc3ee317b37e5781" 7674 7674 + dependencies = [ 7675 7675 + "block2", 7676 7676 + "objc2", 7677 7677 + "objc2-contacts", 7678 7678 + "objc2-foundation", 7679 7679 + ] 7680 7680 + 7681 7681 + [[package]] 7682 7682 + name = "objc2-encode" 7683 7683 + version = "4.1.0" 7684 7684 + source = "registry+https://github.com/rust-lang/crates.io-index" 7685 7685 + checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33" 7686 7686 + 7687 7687 + [[package]] 7688 7688 + name = "objc2-foundation" 7689 7689 + version = "0.2.2" 7690 7690 + source = "registry+https://github.com/rust-lang/crates.io-index" 7691 7691 + checksum = "0ee638a5da3799329310ad4cfa62fbf045d5f56e3ef5ba4149e7452dcf89d5a8" 7692 7692 + dependencies = [ 7693 7693 + "bitflags 2.6.0", 7694 7694 + "block2", 7695 7695 + "dispatch", 7696 7696 + "libc", 7697 7697 + "objc2", 7698 7698 + ] 7699 7699 + 7700 7700 + [[package]] 7701 7701 + name = "objc2-link-presentation" 7702 7702 + version = "0.2.2" 7703 7703 + source = "registry+https://github.com/rust-lang/crates.io-index" 7704 7704 + checksum = "a1a1ae721c5e35be65f01a03b6d2ac13a54cb4fa70d8a5da293d7b0020261398" 7705 7705 + dependencies = [ 7706 7706 + "block2", 7707 7707 + "objc2", 7708 7708 + "objc2-app-kit", 7709 7709 + "objc2-foundation", 7710 7710 + ] 7711 7711 + 7712 7712 + [[package]] 7713 7713 + name = "objc2-metal" 7714 7714 + version = "0.2.2" 7715 7715 + source = "registry+https://github.com/rust-lang/crates.io-index" 7716 7716 + checksum = "dd0cba1276f6023976a406a14ffa85e1fdd19df6b0f737b063b95f6c8c7aadd6" 7717 7717 + dependencies = [ 7718 7718 + "bitflags 2.6.0", 7719 7719 + "block2", 7720 7720 + "objc2", 7721 7721 + "objc2-foundation", 7722 7722 + ] 7723 7723 + 7724 7724 + [[package]] 7725 7725 + name = "objc2-quartz-core" 7726 7726 + version = "0.2.2" 7727 7727 + source = "registry+https://github.com/rust-lang/crates.io-index" 7728 7728 + checksum = "e42bee7bff906b14b167da2bac5efe6b6a07e6f7c0a21a7308d40c960242dc7a" 7729 7729 + dependencies = [ 7730 7730 + "bitflags 2.6.0", 7731 7731 + "block2", 7732 7732 + "objc2", 7733 7733 + "objc2-foundation", 7734 7734 + "objc2-metal", 7735 7735 + ] 7736 7736 + 7737 7737 + [[package]] 7738 7738 + name = "objc2-symbols" 7739 7739 + version = "0.2.2" 7740 7740 + source = "registry+https://github.com/rust-lang/crates.io-index" 7741 7741 + checksum = "0a684efe3dec1b305badae1a28f6555f6ddd3bb2c2267896782858d5a78404dc" 7742 7742 + dependencies = [ 7743 7743 + "objc2", 7744 7744 + "objc2-foundation", 7745 7745 + ] 7746 7746 + 7747 7747 + [[package]] 7748 7748 + name = "objc2-ui-kit" 7749 7749 + version = "0.2.2" 7750 7750 + source = "registry+https://github.com/rust-lang/crates.io-index" 7751 7751 + checksum = "b8bb46798b20cd6b91cbd113524c490f1686f4c4e8f49502431415f3512e2b6f" 7752 7752 + dependencies = [ 7753 7753 + "bitflags 2.6.0", 7754 7754 + "block2", 7755 7755 + "objc2", 7756 7756 + "objc2-cloud-kit", 7757 7757 + "objc2-core-data", 7758 7758 + "objc2-core-image", 7759 7759 + "objc2-core-location", 7760 7760 + "objc2-foundation", 7761 7761 + "objc2-link-presentation", 7762 7762 + "objc2-quartz-core", 7763 7763 + "objc2-symbols", 7764 7764 + "objc2-uniform-type-identifiers", 7765 7765 + "objc2-user-notifications", 7766 7766 + ] 7767 7767 + 7768 7768 + [[package]] 7769 7769 + name = "objc2-uniform-type-identifiers" 7770 7770 + version = "0.2.2" 7771 7771 + source = "registry+https://github.com/rust-lang/crates.io-index" 7772 7772 + checksum = "44fa5f9748dbfe1ca6c0b79ad20725a11eca7c2218bceb4b005cb1be26273bfe" 7773 7773 + dependencies = [ 7774 7774 + "block2", 7775 7775 + "objc2", 7776 7776 + "objc2-foundation", 7777 7777 + ] 7778 7778 + 7779 7779 + [[package]] 7780 7780 + name = "objc2-user-notifications" 7781 7781 + version = "0.2.2" 7782 7782 + source = "registry+https://github.com/rust-lang/crates.io-index" 7783 7783 + checksum = "76cfcbf642358e8689af64cee815d139339f3ed8ad05103ed5eaf73db8d84cb3" 7784 7784 + dependencies = [ 7785 7785 + "bitflags 2.6.0", 7786 7786 + "block2", 7787 7787 + "objc2", 7788 7788 + "objc2-core-location", 7789 7789 + "objc2-foundation", 7790 7790 + ] 7791 7791 + 7792 7792 + [[package]] 7293 7793 name = "object" 7294 7794 version = "0.36.4" 7295 7795 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 7456 7956 checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" 7457 7957 7458 7958 [[package]] 7959 7959 + name = "orbclient" 7960 7960 + version = "0.3.49" 7961 7961 + source = "registry+https://github.com/rust-lang/crates.io-index" 7962 7962 + checksum = "247ad146e19b9437f8604c21f8652423595cf710ad108af40e77d3ae6e96b827" 7963 7963 + dependencies = [ 7964 7964 + "libredox", 7965 7965 + ] 7966 7966 + 7967 7967 + [[package]] 7459 7968 name = "ordered-float" 7460 7969 version = "2.10.1" 7461 7970 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 7506 8015 checksum = "4030760ffd992bef45b0ae3f10ce1aba99e33464c90d14dd7c039884963ddc7a" 7507 8016 7508 8017 [[package]] 8018 8018 + name = "owned_ttf_parser" 8019 8019 + version = "0.25.1" 8020 8020 + source = "registry+https://github.com/rust-lang/crates.io-index" 8021 8021 + checksum = "36820e9051aca1014ddc75770aab4d68bc1e9e632f0f5627c4086bc216fb583b" 8022 8022 + dependencies = [ 8023 8023 + "ttf-parser", 8024 8024 + ] 8025 8025 + 8026 8026 + [[package]] 7509 8027 name = "ownedbytes" 7510 8028 version = "0.7.0" 7511 8029 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 7624 8142 dependencies = [ 7625 8143 "cfg-if 1.0.0", 7626 8144 "libc", 7627 7627 - "redox_syscall", 8145 8145 + "redox_syscall 0.5.3", 7628 8146 "smallvec", 7629 8147 "windows-targets 0.52.6", 7630 8148 ] ··· 7925 8443 "concurrent-queue", 7926 8444 "hermit-abi 0.4.0", 7927 8445 "pin-project-lite", 7928 7928 - "rustix", 8446 8446 + "rustix 0.38.42", 7929 8447 "tracing", 7930 8448 "windows-sys 0.59.0", 7931 8449 ] ··· 8282 8800 dependencies = [ 8283 8801 "chrono", 8284 8802 "indexmap 2.5.0", 8285 8285 - "quick-xml", 8803 8803 + "quick-xml 0.31.0", 8286 8804 "strip-ansi-escapes", 8287 8805 "thiserror 1.0.63", 8288 8806 "uuid", ··· 8293 8811 version = "0.31.0" 8294 8812 source = "registry+https://github.com/rust-lang/crates.io-index" 8295 8813 checksum = "1004a344b30a54e2ee58d66a71b32d2db2feb0a31f9a2d302bf0536f15de2a33" 8814 8814 + dependencies = [ 8815 8815 + "memchr", 8816 8816 + ] 8817 8817 + 8818 8818 + [[package]] 8819 8819 + name = "quick-xml" 8820 8820 + version = "0.37.5" 8821 8821 + source = "registry+https://github.com/rust-lang/crates.io-index" 8822 8822 + checksum = "331e97a1af0bf59823e6eadffe373d7b27f485be8748f71471c662c1f269b7fb" 8296 8823 dependencies = [ 8297 8824 "memchr", 8298 8825 ] ··· 8591 9118 8592 9119 [[package]] 8593 9120 name = "redox_syscall" 9121 9121 + version = "0.4.1" 9122 9122 + source = "registry+https://github.com/rust-lang/crates.io-index" 9123 9123 + checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" 9124 9124 + dependencies = [ 9125 9125 + "bitflags 1.3.2", 9126 9126 + ] 9127 9127 + 9128 9128 + [[package]] 9129 9129 + name = "redox_syscall" 8594 9130 version = "0.5.3" 8595 9131 source = "registry+https://github.com/rust-lang/crates.io-index" 8596 9132 checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4" ··· 8803 9339 "log", 8804 9340 "ratatui", 8805 9341 "ron", 8806 8806 - "rustix", 9342 9342 + "rustix 0.38.42", 8807 9343 "serde", 8808 9344 "serde_json", 8809 9345 "serde_with", ··· 8833 9369 "prost", 8834 9370 "reqwest", 8835 9371 "rmpc", 9372 9372 + "rockbox-controls", 8836 9373 "serde", 8837 9374 "serde_json", 8838 9375 "tokio", ··· 8877 9414 ] 8878 9415 8879 9416 [[package]] 9417 9417 + name = "rockbox-controls" 9418 9418 + version = "0.1.0" 9419 9419 + dependencies = [ 9420 9420 + "anyhow", 9421 9421 + "prost", 9422 9422 + "rockbox-library", 9423 9423 + "souvlaki", 9424 9424 + "tokio", 9425 9425 + "tonic", 9426 9426 + "tonic-build", 9427 9427 + "urlencoding", 9428 9428 + "winit", 9429 9429 + ] 9430 9430 + 9431 9431 + [[package]] 8880 9432 name = "rockbox-discovery" 8881 9433 version = "0.1.0" 8882 9434 dependencies = [ ··· 9353 9905 "bitflags 2.6.0", 9354 9906 "errno 0.3.10", 9355 9907 "libc", 9356 9356 - "linux-raw-sys", 9908 9908 + "linux-raw-sys 0.4.14", 9909 9909 + "windows-sys 0.59.0", 9910 9910 + ] 9911 9911 + 9912 9912 + [[package]] 9913 9913 + name = "rustix" 9914 9914 + version = "1.1.2" 9915 9915 + source = "registry+https://github.com/rust-lang/crates.io-index" 9916 9916 + checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e" 9917 9917 + dependencies = [ 9918 9918 + "bitflags 2.6.0", 9919 9919 + "errno 0.3.10", 9920 9920 + "libc", 9921 9921 + "linux-raw-sys 0.11.0", 9357 9922 "windows-sys 0.59.0", 9358 9923 ] 9359 9924 ··· 9572 10137 ] 9573 10138 9574 10139 [[package]] 10140 10140 + name = "sctk-adwaita" 10141 10141 + version = "0.10.1" 10142 10142 + source = "registry+https://github.com/rust-lang/crates.io-index" 10143 10143 + checksum = "b6277f0217056f77f1d8f49f2950ac6c278c0d607c45f5ee99328d792ede24ec" 10144 10144 + dependencies = [ 10145 10145 + "ab_glyph", 10146 10146 + "log", 10147 10147 + "memmap2 0.9.5", 10148 10148 + "smithay-client-toolkit", 10149 10149 + "tiny-skia", 10150 10150 + ] 10151 10151 + 10152 10152 + [[package]] 9575 10153 name = "sec1" 9576 10154 version = "0.7.3" 9577 10155 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 10014 10592 checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c" 10015 10593 10016 10594 [[package]] 10595 10595 + name = "smithay-client-toolkit" 10596 10596 + version = "0.19.2" 10597 10597 + source = "registry+https://github.com/rust-lang/crates.io-index" 10598 10598 + checksum = "3457dea1f0eb631b4034d61d4d8c32074caa6cd1ab2d59f2327bd8461e2c0016" 10599 10599 + dependencies = [ 10600 10600 + "bitflags 2.6.0", 10601 10601 + "calloop", 10602 10602 + "calloop-wayland-source", 10603 10603 + "cursor-icon", 10604 10604 + "libc", 10605 10605 + "log", 10606 10606 + "memmap2 0.9.5", 10607 10607 + "rustix 0.38.42", 10608 10608 + "thiserror 1.0.63", 10609 10609 + "wayland-backend", 10610 10610 + "wayland-client", 10611 10611 + "wayland-csd-frame", 10612 10612 + "wayland-cursor", 10613 10613 + "wayland-protocols", 10614 10614 + "wayland-protocols-wlr", 10615 10615 + "wayland-scanner", 10616 10616 + "xkeysym", 10617 10617 + ] 10618 10618 + 10619 10619 + [[package]] 10620 10620 + name = "smol_str" 10621 10621 + version = "0.2.2" 10622 10622 + source = "registry+https://github.com/rust-lang/crates.io-index" 10623 10623 + checksum = "dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead" 10624 10624 + dependencies = [ 10625 10625 + "serde", 10626 10626 + ] 10627 10627 + 10628 10628 + [[package]] 10017 10629 name = "socket2" 10018 10630 version = "0.4.10" 10019 10631 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 10069 10681 "serde_json", 10070 10682 "unicode-id-start", 10071 10683 "url", 10684 10684 + ] 10685 10685 + 10686 10686 + [[package]] 10687 10687 + name = "souvlaki" 10688 10688 + version = "0.8.3" 10689 10689 + source = "registry+https://github.com/rust-lang/crates.io-index" 10690 10690 + checksum = "5855c8f31521af07d896b852eaa9eca974ddd3211fc2ae292e58dda8eb129bc8" 10691 10691 + dependencies = [ 10692 10692 + "base64 0.22.1", 10693 10693 + "block", 10694 10694 + "cocoa", 10695 10695 + "core-graphics 0.22.3", 10696 10696 + "dbus", 10697 10697 + "dbus-crossroads", 10698 10698 + "dispatch", 10699 10699 + "objc", 10700 10700 + "thiserror 1.0.63", 10701 10701 + "windows 0.44.0", 10072 10702 ] 10073 10703 10074 10704 [[package]] ··· 10354 10984 checksum = "d7beae5182595e9a8b683fa98c4317f956c9a2dec3b9716990d20023cc60c766" 10355 10985 10356 10986 [[package]] 10987 10987 + name = "strict-num" 10988 10988 + version = "0.1.1" 10989 10989 + source = "registry+https://github.com/rust-lang/crates.io-index" 10990 10990 + checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731" 10991 10991 + 10992 10992 + [[package]] 10357 10993 name = "string_enum" 10358 10994 version = "0.4.4" 10359 10995 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 11169 11805 "cfg-if 1.0.0", 11170 11806 "fastrand", 11171 11807 "once_cell", 11172 11172 - "rustix", 11808 11808 + "rustix 0.38.42", 11173 11809 "windows-sys 0.59.0", 11174 11810 ] 11175 11811 ··· 11188 11824 source = "registry+https://github.com/rust-lang/crates.io-index" 11189 11825 checksum = "21bebf2b7c9e0a515f6e0f8c51dc0f8e4696391e6f1ff30379559f8365fb0df7" 11190 11826 dependencies = [ 11191 11191 - "rustix", 11827 11827 + "rustix 0.38.42", 11192 11828 "windows-sys 0.48.0", 11193 11829 ] 11194 11830 ··· 11375 12011 dependencies = [ 11376 12012 "num-conv", 11377 12013 "time-core", 12014 12014 + ] 12015 12015 + 12016 12016 + [[package]] 12017 12017 + name = "tiny-skia" 12018 12018 + version = "0.11.4" 12019 12019 + source = "registry+https://github.com/rust-lang/crates.io-index" 12020 12020 + checksum = "83d13394d44dae3207b52a326c0c85a8bf87f1541f23b0d143811088497b09ab" 12021 12021 + dependencies = [ 12022 12022 + "arrayref", 12023 12023 + "arrayvec", 12024 12024 + "bytemuck", 12025 12025 + "cfg-if 1.0.0", 12026 12026 + "log", 12027 12027 + "tiny-skia-path", 12028 12028 + ] 12029 12029 + 12030 12030 + [[package]] 12031 12031 + name = "tiny-skia-path" 12032 12032 + version = "0.11.4" 12033 12033 + source = "registry+https://github.com/rust-lang/crates.io-index" 12034 12034 + checksum = "9c9e7fc0c2e86a30b117d0462aa261b72b7a99b7ebd7deb3a14ceda95c5bdc93" 12035 12035 + dependencies = [ 12036 12036 + "arrayref", 12037 12037 + "bytemuck", 12038 12038 + "strict-num", 11378 12039 ] 11379 12040 11380 12041 [[package]] ··· 11805 12466 checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" 11806 12467 11807 12468 [[package]] 12469 12469 + name = "ttf-parser" 12470 12470 + version = "0.25.1" 12471 12471 + source = "registry+https://github.com/rust-lang/crates.io-index" 12472 12472 + checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31" 12473 12473 + 12474 12474 + [[package]] 11808 12475 name = "tungstenite" 11809 12476 version = "0.21.0" 11810 12477 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 12415 13082 ] 12416 13083 12417 13084 [[package]] 13085 13085 + name = "wayland-backend" 13086 13086 + version = "0.3.11" 13087 13087 + source = "registry+https://github.com/rust-lang/crates.io-index" 13088 13088 + checksum = "673a33c33048a5ade91a6b139580fa174e19fb0d23f396dca9fa15f2e1e49b35" 13089 13089 + dependencies = [ 13090 13090 + "cc", 13091 13091 + "downcast-rs", 13092 13092 + "rustix 1.1.2", 13093 13093 + "scoped-tls", 13094 13094 + "smallvec", 13095 13095 + "wayland-sys", 13096 13096 + ] 13097 13097 + 13098 13098 + [[package]] 13099 13099 + name = "wayland-client" 13100 13100 + version = "0.31.11" 13101 13101 + source = "registry+https://github.com/rust-lang/crates.io-index" 13102 13102 + checksum = "c66a47e840dc20793f2264eb4b3e4ecb4b75d91c0dd4af04b456128e0bdd449d" 13103 13103 + dependencies = [ 13104 13104 + "bitflags 2.6.0", 13105 13105 + "rustix 1.1.2", 13106 13106 + "wayland-backend", 13107 13107 + "wayland-scanner", 13108 13108 + ] 13109 13109 + 13110 13110 + [[package]] 13111 13111 + name = "wayland-csd-frame" 13112 13112 + version = "0.3.0" 13113 13113 + source = "registry+https://github.com/rust-lang/crates.io-index" 13114 13114 + checksum = "625c5029dbd43d25e6aa9615e88b829a5cad13b2819c4ae129fdbb7c31ab4c7e" 13115 13115 + dependencies = [ 13116 13116 + "bitflags 2.6.0", 13117 13117 + "cursor-icon", 13118 13118 + "wayland-backend", 13119 13119 + ] 13120 13120 + 13121 13121 + [[package]] 13122 13122 + name = "wayland-cursor" 13123 13123 + version = "0.31.11" 13124 13124 + source = "registry+https://github.com/rust-lang/crates.io-index" 13125 13125 + checksum = "447ccc440a881271b19e9989f75726d60faa09b95b0200a9b7eb5cc47c3eeb29" 13126 13126 + dependencies = [ 13127 13127 + "rustix 1.1.2", 13128 13128 + "wayland-client", 13129 13129 + "xcursor", 13130 13130 + ] 13131 13131 + 13132 13132 + [[package]] 13133 13133 + name = "wayland-protocols" 13134 13134 + version = "0.32.9" 13135 13135 + source = "registry+https://github.com/rust-lang/crates.io-index" 13136 13136 + checksum = "efa790ed75fbfd71283bd2521a1cfdc022aabcc28bdcff00851f9e4ae88d9901" 13137 13137 + dependencies = [ 13138 13138 + "bitflags 2.6.0", 13139 13139 + "wayland-backend", 13140 13140 + "wayland-client", 13141 13141 + "wayland-scanner", 13142 13142 + ] 13143 13143 + 13144 13144 + [[package]] 13145 13145 + name = "wayland-protocols-plasma" 13146 13146 + version = "0.3.9" 13147 13147 + source = "registry+https://github.com/rust-lang/crates.io-index" 13148 13148 + checksum = "a07a14257c077ab3279987c4f8bb987851bf57081b93710381daea94f2c2c032" 13149 13149 + dependencies = [ 13150 13150 + "bitflags 2.6.0", 13151 13151 + "wayland-backend", 13152 13152 + "wayland-client", 13153 13153 + "wayland-protocols", 13154 13154 + "wayland-scanner", 13155 13155 + ] 13156 13156 + 13157 13157 + [[package]] 13158 13158 + name = "wayland-protocols-wlr" 13159 13159 + version = "0.3.9" 13160 13160 + source = "registry+https://github.com/rust-lang/crates.io-index" 13161 13161 + checksum = "efd94963ed43cf9938a090ca4f7da58eb55325ec8200c3848963e98dc25b78ec" 13162 13162 + dependencies = [ 13163 13163 + "bitflags 2.6.0", 13164 13164 + "wayland-backend", 13165 13165 + "wayland-client", 13166 13166 + "wayland-protocols", 13167 13167 + "wayland-scanner", 13168 13168 + ] 13169 13169 + 13170 13170 + [[package]] 13171 13171 + name = "wayland-scanner" 13172 13172 + version = "0.31.7" 13173 13173 + source = "registry+https://github.com/rust-lang/crates.io-index" 13174 13174 + checksum = "54cb1e9dc49da91950bdfd8b848c49330536d9d1fb03d4bfec8cae50caa50ae3" 13175 13175 + dependencies = [ 13176 13176 + "proc-macro2", 13177 13177 + "quick-xml 0.37.5", 13178 13178 + "quote", 13179 13179 + ] 13180 13180 + 13181 13181 + [[package]] 13182 13182 + name = "wayland-sys" 13183 13183 + version = "0.31.7" 13184 13184 + source = "registry+https://github.com/rust-lang/crates.io-index" 13185 13185 + checksum = "34949b42822155826b41db8e5d0c1be3a2bd296c747577a43a3e6daefc296142" 13186 13186 + dependencies = [ 13187 13187 + "dlib", 13188 13188 + "log", 13189 13189 + "once_cell", 13190 13190 + "pkg-config", 13191 13191 + ] 13192 13192 + 13193 13193 + [[package]] 12418 13194 name = "web-sys" 12419 13195 version = "0.3.76" 12420 13196 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 12532 13308 "log", 12533 13309 "metal", 12534 13310 "naga", 12535 12535 - "ndk-sys", 13311 13311 + "ndk-sys 0.5.0+25.2.9519653", 12536 13312 "objc", 12537 13313 "once_cell", 12538 13314 "parking_lot", ··· 12569 13345 "either", 12570 13346 "home", 12571 13347 "once_cell", 12572 12572 - "rustix", 13348 13348 + "rustix 0.38.42", 12573 13349 ] 12574 13350 12575 13351 [[package]] ··· 12580 13356 dependencies = [ 12581 13357 "either", 12582 13358 "home", 12583 12583 - "rustix", 13359 13359 + "rustix 0.38.42", 12584 13360 "winsafe", 12585 13361 ] 12586 13362 ··· 12590 13366 source = "registry+https://github.com/rust-lang/crates.io-index" 12591 13367 checksum = "372d5b87f58ec45c384ba03563b03544dc5fadc3983e434b286913f5b4a9bb6d" 12592 13368 dependencies = [ 12593 12593 - "redox_syscall", 13369 13369 + "redox_syscall 0.5.3", 12594 13370 "wasite", 12595 13371 "web-sys", 12596 13372 ] ··· 12644 13420 12645 13421 [[package]] 12646 13422 name = "windows" 13423 13423 + version = "0.44.0" 13424 13424 + source = "registry+https://github.com/rust-lang/crates.io-index" 13425 13425 + checksum = "9e745dab35a0c4c77aa3ce42d595e13d2003d6902d6b08c9ef5fc326d08da12b" 13426 13426 + dependencies = [ 13427 13427 + "windows-targets 0.42.2", 13428 13428 + ] 13429 13429 + 13430 13430 + [[package]] 13431 13431 + name = "windows" 12647 13432 version = "0.52.0" 12648 13433 source = "registry+https://github.com/rust-lang/crates.io-index" 12649 13434 checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be" ··· 12706 13491 ] 12707 13492 12708 13493 [[package]] 13494 13494 + name = "windows-link" 13495 13495 + version = "0.2.1" 13496 13496 + source = "registry+https://github.com/rust-lang/crates.io-index" 13497 13497 + checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" 13498 13498 + 13499 13499 + [[package]] 12709 13500 name = "windows-result" 12710 13501 version = "0.1.2" 12711 13502 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 12716 13507 12717 13508 [[package]] 12718 13509 name = "windows-sys" 13510 13510 + version = "0.45.0" 13511 13511 + source = "registry+https://github.com/rust-lang/crates.io-index" 13512 13512 + checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0" 13513 13513 + dependencies = [ 13514 13514 + "windows-targets 0.42.2", 13515 13515 + ] 13516 13516 + 13517 13517 + [[package]] 13518 13518 + name = "windows-sys" 12719 13519 version = "0.48.0" 12720 13520 source = "registry+https://github.com/rust-lang/crates.io-index" 12721 13521 checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" ··· 12743 13543 12744 13544 [[package]] 12745 13545 name = "windows-targets" 13546 13546 + version = "0.42.2" 13547 13547 + source = "registry+https://github.com/rust-lang/crates.io-index" 13548 13548 + checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071" 13549 13549 + dependencies = [ 13550 13550 + "windows_aarch64_gnullvm 0.42.2", 13551 13551 + "windows_aarch64_msvc 0.42.2", 13552 13552 + "windows_i686_gnu 0.42.2", 13553 13553 + "windows_i686_msvc 0.42.2", 13554 13554 + "windows_x86_64_gnu 0.42.2", 13555 13555 + "windows_x86_64_gnullvm 0.42.2", 13556 13556 + "windows_x86_64_msvc 0.42.2", 13557 13557 + ] 13558 13558 + 13559 13559 + [[package]] 13560 13560 + name = "windows-targets" 12746 13561 version = "0.48.5" 12747 13562 source = "registry+https://github.com/rust-lang/crates.io-index" 12748 13563 checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" ··· 12771 13586 "windows_x86_64_gnullvm 0.52.6", 12772 13587 "windows_x86_64_msvc 0.52.6", 12773 13588 ] 13589 13589 + 13590 13590 + [[package]] 13591 13591 + name = "windows_aarch64_gnullvm" 13592 13592 + version = "0.42.2" 13593 13593 + source = "registry+https://github.com/rust-lang/crates.io-index" 13594 13594 + checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8" 12774 13595 12775 13596 [[package]] 12776 13597 name = "windows_aarch64_gnullvm" ··· 12786 13607 12787 13608 [[package]] 12788 13609 name = "windows_aarch64_msvc" 13610 13610 + version = "0.42.2" 13611 13611 + source = "registry+https://github.com/rust-lang/crates.io-index" 13612 13612 + checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43" 13613 13613 + 13614 13614 + [[package]] 13615 13615 + name = "windows_aarch64_msvc" 12789 13616 version = "0.48.5" 12790 13617 source = "registry+https://github.com/rust-lang/crates.io-index" 12791 13618 checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" ··· 12798 13625 12799 13626 [[package]] 12800 13627 name = "windows_i686_gnu" 13628 13628 + version = "0.42.2" 13629 13629 + source = "registry+https://github.com/rust-lang/crates.io-index" 13630 13630 + checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f" 13631 13631 + 13632 13632 + [[package]] 13633 13633 + name = "windows_i686_gnu" 12801 13634 version = "0.48.5" 12802 13635 source = "registry+https://github.com/rust-lang/crates.io-index" 12803 13636 checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" ··· 12816 13649 12817 13650 [[package]] 12818 13651 name = "windows_i686_msvc" 13652 13652 + version = "0.42.2" 13653 13653 + source = "registry+https://github.com/rust-lang/crates.io-index" 13654 13654 + checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060" 13655 13655 + 13656 13656 + [[package]] 13657 13657 + name = "windows_i686_msvc" 12819 13658 version = "0.48.5" 12820 13659 source = "registry+https://github.com/rust-lang/crates.io-index" 12821 13660 checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" ··· 12828 13667 12829 13668 [[package]] 12830 13669 name = "windows_x86_64_gnu" 13670 13670 + version = "0.42.2" 13671 13671 + source = "registry+https://github.com/rust-lang/crates.io-index" 13672 13672 + checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36" 13673 13673 + 13674 13674 + [[package]] 13675 13675 + name = "windows_x86_64_gnu" 12831 13676 version = "0.48.5" 12832 13677 source = "registry+https://github.com/rust-lang/crates.io-index" 12833 13678 checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" ··· 12840 13685 12841 13686 [[package]] 12842 13687 name = "windows_x86_64_gnullvm" 13688 13688 + version = "0.42.2" 13689 13689 + source = "registry+https://github.com/rust-lang/crates.io-index" 13690 13690 + checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3" 13691 13691 + 13692 13692 + [[package]] 13693 13693 + name = "windows_x86_64_gnullvm" 12843 13694 version = "0.48.5" 12844 13695 source = "registry+https://github.com/rust-lang/crates.io-index" 12845 13696 checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" ··· 12852 13703 12853 13704 [[package]] 12854 13705 name = "windows_x86_64_msvc" 13706 13706 + version = "0.42.2" 13707 13707 + source = "registry+https://github.com/rust-lang/crates.io-index" 13708 13708 + checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0" 13709 13709 + 13710 13710 + [[package]] 13711 13711 + name = "windows_x86_64_msvc" 12855 13712 version = "0.48.5" 12856 13713 source = "registry+https://github.com/rust-lang/crates.io-index" 12857 13714 checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" ··· 12863 13720 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" 12864 13721 12865 13722 [[package]] 13723 13723 + name = "winit" 13724 13724 + version = "0.30.12" 13725 13725 + source = "registry+https://github.com/rust-lang/crates.io-index" 13726 13726 + checksum = "c66d4b9ed69c4009f6321f762d6e61ad8a2389cd431b97cb1e146812e9e6c732" 13727 13727 + dependencies = [ 13728 13728 + "ahash", 13729 13729 + "android-activity", 13730 13730 + "atomic-waker", 13731 13731 + "bitflags 2.6.0", 13732 13732 + "block2", 13733 13733 + "bytemuck", 13734 13734 + "calloop", 13735 13735 + "cfg_aliases 0.2.1", 13736 13736 + "concurrent-queue", 13737 13737 + "core-foundation", 13738 13738 + "core-graphics 0.23.2", 13739 13739 + "cursor-icon", 13740 13740 + "dpi", 13741 13741 + "js-sys", 13742 13742 + "libc", 13743 13743 + "memmap2 0.9.5", 13744 13744 + "ndk", 13745 13745 + "objc2", 13746 13746 + "objc2-app-kit", 13747 13747 + "objc2-foundation", 13748 13748 + "objc2-ui-kit", 13749 13749 + "orbclient", 13750 13750 + "percent-encoding", 13751 13751 + "pin-project", 13752 13752 + "raw-window-handle", 13753 13753 + "redox_syscall 0.4.1", 13754 13754 + "rustix 0.38.42", 13755 13755 + "sctk-adwaita", 13756 13756 + "smithay-client-toolkit", 13757 13757 + "smol_str", 13758 13758 + "tracing", 13759 13759 + "unicode-segmentation", 13760 13760 + "wasm-bindgen", 13761 13761 + "wasm-bindgen-futures", 13762 13762 + "wayland-backend", 13763 13763 + "wayland-client", 13764 13764 + "wayland-protocols", 13765 13765 + "wayland-protocols-plasma", 13766 13766 + "web-sys", 13767 13767 + "web-time", 13768 13768 + "windows-sys 0.52.0", 13769 13769 + "x11-dl", 13770 13770 + "x11rb", 13771 13771 + "xkbcommon-dl", 13772 13772 + ] 13773 13773 + 13774 13774 + [[package]] 12866 13775 name = "winnow" 12867 13776 version = "0.6.20" 12868 13777 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 12943 13852 ] 12944 13853 12945 13854 [[package]] 13855 13855 + name = "x11-dl" 13856 13856 + version = "2.21.0" 13857 13857 + source = "registry+https://github.com/rust-lang/crates.io-index" 13858 13858 + checksum = "38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f" 13859 13859 + dependencies = [ 13860 13860 + "libc", 13861 13861 + "once_cell", 13862 13862 + "pkg-config", 13863 13863 + ] 13864 13864 + 13865 13865 + [[package]] 13866 13866 + name = "x11rb" 13867 13867 + version = "0.13.2" 13868 13868 + source = "registry+https://github.com/rust-lang/crates.io-index" 13869 13869 + checksum = "9993aa5be5a26815fe2c3eacfc1fde061fc1a1f094bf1ad2a18bf9c495dd7414" 13870 13870 + dependencies = [ 13871 13871 + "as-raw-xcb-connection", 13872 13872 + "gethostname", 13873 13873 + "libc", 13874 13874 + "libloading 0.8.5", 13875 13875 + "once_cell", 13876 13876 + "rustix 1.1.2", 13877 13877 + "x11rb-protocol", 13878 13878 + ] 13879 13879 + 13880 13880 + [[package]] 13881 13881 + name = "x11rb-protocol" 13882 13882 + version = "0.13.2" 13883 13883 + source = "registry+https://github.com/rust-lang/crates.io-index" 13884 13884 + checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd" 13885 13885 + 13886 13886 + [[package]] 12946 13887 name = "x25519-dalek" 12947 13888 version = "2.0.1" 12948 13889 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 12978 13919 checksum = "8da84f1a25939b27f6820d92aed108f83ff920fdf11a7b19366c27c4cda81d4f" 12979 13920 dependencies = [ 12980 13921 "libc", 12981 12981 - "linux-raw-sys", 12982 12982 - "rustix", 13922 13922 + "linux-raw-sys 0.4.14", 13923 13923 + "rustix 0.38.42", 12983 13924 ] 12984 13925 12985 13926 [[package]] 13927 13927 + name = "xcursor" 13928 13928 + version = "0.3.10" 13929 13929 + source = "registry+https://github.com/rust-lang/crates.io-index" 13930 13930 + checksum = "bec9e4a500ca8864c5b47b8b482a73d62e4237670e5b5f1d6b9e3cae50f28f2b" 13931 13931 + 13932 13932 + [[package]] 12986 13933 name = "xdg-home" 12987 13934 version = "1.3.0" 12988 13935 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 12991 13938 "libc", 12992 13939 "windows-sys 0.59.0", 12993 13940 ] 13941 13941 + 13942 13942 + [[package]] 13943 13943 + name = "xkbcommon-dl" 13944 13944 + version = "0.4.2" 13945 13945 + source = "registry+https://github.com/rust-lang/crates.io-index" 13946 13946 + checksum = "d039de8032a9a8856a6be89cea3e5d12fdd82306ab7c94d74e6deab2460651c5" 13947 13947 + dependencies = [ 13948 13948 + "bitflags 2.6.0", 13949 13949 + "dlib", 13950 13950 + "log", 13951 13951 + "once_cell", 13952 13952 + "xkeysym", 13953 13953 + ] 13954 13954 + 13955 13955 + [[package]] 13956 13956 + name = "xkeysym" 13957 13957 + version = "0.2.1" 13958 13958 + source = "registry+https://github.com/rust-lang/crates.io-index" 13959 13959 + checksum = "b9cc00251562a284751c9973bace760d86c0276c471b4be569fe6b068ee97a56" 12994 13960 12995 13961 [[package]] 12996 13962 name = "xml-rs"

+1

cli/Cargo.toml

··· 27 27 "rustls-tls", 28 28 "json", 29 29 ], default-features = false } 30 30 + rockbox-controls = { path = "../crates/controls"} 30 31 serde = { version = "1.0.210", features = ["derive"] } 31 32 serde_json = "1.0.128" 32 33 open = "5.3.2"

+2470 -1224

cli/src/api/rockbox.v1alpha1.rs

··· 43 43 dead_code, 44 44 missing_docs, 45 45 clippy::wildcard_imports, 46 46 - clippy::let_unit_value 46 46 + clippy::let_unit_value, 47 47 )] 48 48 - use tonic::codegen::http::Uri; 49 48 use tonic::codegen::*; 49 49 + use tonic::codegen::http::Uri; 50 50 #[derive(Debug, Clone)] 51 51 pub struct BrowseServiceClient<T> { 52 52 inner: tonic::client::Grpc<T>, ··· 90 90 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 91 91 >, 92 92 >, 93 93 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 94 94 - Into<StdError> + std::marker::Send + std::marker::Sync, 93 93 + <T as tonic::codegen::Service< 94 94 + http::Request<tonic::body::BoxBody>, 95 95 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 95 96 { 96 97 BrowseServiceClient::new(InterceptedService::new(inner, interceptor)) 97 98 } ··· 129 130 pub async fn tree_get_entries( 130 131 &mut self, 131 132 request: impl tonic::IntoRequest<super::TreeGetEntriesRequest>, 132 132 - ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status> 133 133 - { 134 134 - self.inner.ready().await.map_err(|e| { 135 135 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 136 136 - })?; 133 133 + ) -> std::result::Result< 134 134 + tonic::Response<super::TreeGetEntriesResponse>, 135 135 + tonic::Status, 136 136 + > { 137 137 + self.inner 138 138 + .ready() 139 139 + .await 140 140 + .map_err(|e| { 141 141 + tonic::Status::unknown( 142 142 + format!("Service was not ready: {}", e.into()), 143 143 + ) 144 144 + })?; 137 145 let codec = tonic::codec::ProstCodec::default(); 138 146 let path = http::uri::PathAndQuery::from_static( 139 147 "/rockbox.v1alpha1.BrowseService/TreeGetEntries", 140 148 ); 141 149 let mut req = request.into_request(); 142 142 - req.extensions_mut().insert(GrpcMethod::new( 143 143 - "rockbox.v1alpha1.BrowseService", 144 144 - "TreeGetEntries", 145 145 - )); 150 150 + req.extensions_mut() 151 151 + .insert( 152 152 + GrpcMethod::new("rockbox.v1alpha1.BrowseService", "TreeGetEntries"), 153 153 + ); 146 154 self.inner.unary(req, path, codec).await 147 155 } 148 156 } ··· 154 162 dead_code, 155 163 missing_docs, 156 164 clippy::wildcard_imports, 157 157 - clippy::let_unit_value 165 165 + clippy::let_unit_value, 158 166 )] 159 167 use tonic::codegen::*; 160 168 /// Generated trait containing gRPC methods that should be implemented for use with BrowseServiceServer. ··· 163 171 async fn tree_get_entries( 164 172 &self, 165 173 request: tonic::Request<super::TreeGetEntriesRequest>, 166 166 - ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status>; 174 174 + ) -> std::result::Result< 175 175 + tonic::Response<super::TreeGetEntriesResponse>, 176 176 + tonic::Status, 177 177 + >; 167 178 } 168 179 #[derive(Debug)] 169 180 pub struct BrowseServiceServer<T> { ··· 186 197 max_encoding_message_size: None, 187 198 } 188 199 } 189 189 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 200 200 + pub fn with_interceptor<F>( 201 201 + inner: T, 202 202 + interceptor: F, 203 203 + ) -> InterceptedService<Self, F> 190 204 where 191 205 F: tonic::service::Interceptor, 192 206 { ··· 241 255 "/rockbox.v1alpha1.BrowseService/TreeGetEntries" => { 242 256 #[allow(non_camel_case_types)] 243 257 struct TreeGetEntriesSvc<T: BrowseService>(pub Arc<T>); 244 244 - impl<T: BrowseService> tonic::server::UnaryService<super::TreeGetEntriesRequest> 245 245 - for TreeGetEntriesSvc<T> 246 246 - { 258 258 + impl< 259 259 + T: BrowseService, 260 260 + > tonic::server::UnaryService<super::TreeGetEntriesRequest> 261 261 + for TreeGetEntriesSvc<T> { 247 262 type Response = super::TreeGetEntriesResponse; 248 248 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 263 263 + type Future = BoxFuture< 264 264 + tonic::Response<Self::Response>, 265 265 + tonic::Status, 266 266 + >; 249 267 fn call( 250 268 &mut self, 251 269 request: tonic::Request<super::TreeGetEntriesRequest>, 252 270 ) -> Self::Future { 253 271 let inner = Arc::clone(&self.0); 254 272 let fut = async move { 255 255 - <T as BrowseService>::tree_get_entries(&inner, request).await 273 273 + <T as BrowseService>::tree_get_entries(&inner, request) 274 274 + .await 256 275 }; 257 276 Box::pin(fut) 258 277 } ··· 279 298 }; 280 299 Box::pin(fut) 281 300 } 282 282 - _ => Box::pin(async move { 283 283 - let mut response = http::Response::new(empty_body()); 284 284 - let headers = response.headers_mut(); 285 285 - headers.insert( 286 286 - tonic::Status::GRPC_STATUS, 287 287 - (tonic::Code::Unimplemented as i32).into(), 288 288 - ); 289 289 - headers.insert( 290 290 - http::header::CONTENT_TYPE, 291 291 - tonic::metadata::GRPC_CONTENT_TYPE, 292 292 - ); 293 293 - Ok(response) 294 294 - }), 301 301 + _ => { 302 302 + Box::pin(async move { 303 303 + let mut response = http::Response::new(empty_body()); 304 304 + let headers = response.headers_mut(); 305 305 + headers 306 306 + .insert( 307 307 + tonic::Status::GRPC_STATUS, 308 308 + (tonic::Code::Unimplemented as i32).into(), 309 309 + ); 310 310 + headers 311 311 + .insert( 312 312 + http::header::CONTENT_TYPE, 313 313 + tonic::metadata::GRPC_CONTENT_TYPE, 314 314 + ); 315 315 + Ok(response) 316 316 + }) 317 317 + } 295 318 } 296 319 } 297 320 } ··· 519 542 dead_code, 520 543 missing_docs, 521 544 clippy::wildcard_imports, 522 522 - clippy::let_unit_value 545 545 + clippy::let_unit_value, 523 546 )] 524 524 - use tonic::codegen::http::Uri; 525 547 use tonic::codegen::*; 548 548 + use tonic::codegen::http::Uri; 526 549 #[derive(Debug, Clone)] 527 550 pub struct LibraryServiceClient<T> { 528 551 inner: tonic::client::Grpc<T>, ··· 566 589 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 567 590 >, 568 591 >, 569 569 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 570 570 - Into<StdError> + std::marker::Send + std::marker::Sync, 592 592 + <T as tonic::codegen::Service< 593 593 + http::Request<tonic::body::BoxBody>, 594 594 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 571 595 { 572 596 LibraryServiceClient::new(InterceptedService::new(inner, interceptor)) 573 597 } ··· 605 629 pub async fn get_albums( 606 630 &mut self, 607 631 request: impl tonic::IntoRequest<super::GetAlbumsRequest>, 608 608 - ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status> { 609 609 - self.inner.ready().await.map_err(|e| { 610 610 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 611 611 - })?; 632 632 + ) -> std::result::Result< 633 633 + tonic::Response<super::GetAlbumsResponse>, 634 634 + tonic::Status, 635 635 + > { 636 636 + self.inner 637 637 + .ready() 638 638 + .await 639 639 + .map_err(|e| { 640 640 + tonic::Status::unknown( 641 641 + format!("Service was not ready: {}", e.into()), 642 642 + ) 643 643 + })?; 612 644 let codec = tonic::codec::ProstCodec::default(); 613 613 - let path = 614 614 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbums"); 645 645 + let path = http::uri::PathAndQuery::from_static( 646 646 + "/rockbox.v1alpha1.LibraryService/GetAlbums", 647 647 + ); 615 648 let mut req = request.into_request(); 616 616 - req.extensions_mut().insert(GrpcMethod::new( 617 617 - "rockbox.v1alpha1.LibraryService", 618 618 - "GetAlbums", 619 619 - )); 649 649 + req.extensions_mut() 650 650 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbums")); 620 651 self.inner.unary(req, path, codec).await 621 652 } 622 653 pub async fn get_artists( 623 654 &mut self, 624 655 request: impl tonic::IntoRequest<super::GetArtistsRequest>, 625 625 - ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status> 626 626 - { 627 627 - self.inner.ready().await.map_err(|e| { 628 628 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 629 629 - })?; 656 656 + ) -> std::result::Result< 657 657 + tonic::Response<super::GetArtistsResponse>, 658 658 + tonic::Status, 659 659 + > { 660 660 + self.inner 661 661 + .ready() 662 662 + .await 663 663 + .map_err(|e| { 664 664 + tonic::Status::unknown( 665 665 + format!("Service was not ready: {}", e.into()), 666 666 + ) 667 667 + })?; 630 668 let codec = tonic::codec::ProstCodec::default(); 631 631 - let path = 632 632 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtists"); 669 669 + let path = http::uri::PathAndQuery::from_static( 670 670 + "/rockbox.v1alpha1.LibraryService/GetArtists", 671 671 + ); 633 672 let mut req = request.into_request(); 634 634 - req.extensions_mut().insert(GrpcMethod::new( 635 635 - "rockbox.v1alpha1.LibraryService", 636 636 - "GetArtists", 637 637 - )); 673 673 + req.extensions_mut() 674 674 + .insert( 675 675 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtists"), 676 676 + ); 638 677 self.inner.unary(req, path, codec).await 639 678 } 640 679 pub async fn get_tracks( 641 680 &mut self, 642 681 request: impl tonic::IntoRequest<super::GetTracksRequest>, 643 643 - ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status> { 644 644 - self.inner.ready().await.map_err(|e| { 645 645 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 646 646 - })?; 682 682 + ) -> std::result::Result< 683 683 + tonic::Response<super::GetTracksResponse>, 684 684 + tonic::Status, 685 685 + > { 686 686 + self.inner 687 687 + .ready() 688 688 + .await 689 689 + .map_err(|e| { 690 690 + tonic::Status::unknown( 691 691 + format!("Service was not ready: {}", e.into()), 692 692 + ) 693 693 + })?; 647 694 let codec = tonic::codec::ProstCodec::default(); 648 648 - let path = 649 649 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTracks"); 695 695 + let path = http::uri::PathAndQuery::from_static( 696 696 + "/rockbox.v1alpha1.LibraryService/GetTracks", 697 697 + ); 650 698 let mut req = request.into_request(); 651 651 - req.extensions_mut().insert(GrpcMethod::new( 652 652 - "rockbox.v1alpha1.LibraryService", 653 653 - "GetTracks", 654 654 - )); 699 699 + req.extensions_mut() 700 700 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTracks")); 655 701 self.inner.unary(req, path, codec).await 656 702 } 657 703 pub async fn get_album( 658 704 &mut self, 659 705 request: impl tonic::IntoRequest<super::GetAlbumRequest>, 660 660 - ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status> { 661 661 - self.inner.ready().await.map_err(|e| { 662 662 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 663 663 - })?; 706 706 + ) -> std::result::Result< 707 707 + tonic::Response<super::GetAlbumResponse>, 708 708 + tonic::Status, 709 709 + > { 710 710 + self.inner 711 711 + .ready() 712 712 + .await 713 713 + .map_err(|e| { 714 714 + tonic::Status::unknown( 715 715 + format!("Service was not ready: {}", e.into()), 716 716 + ) 717 717 + })?; 664 718 let codec = tonic::codec::ProstCodec::default(); 665 665 - let path = 666 666 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbum"); 719 719 + let path = http::uri::PathAndQuery::from_static( 720 720 + "/rockbox.v1alpha1.LibraryService/GetAlbum", 721 721 + ); 667 722 let mut req = request.into_request(); 668 668 - req.extensions_mut().insert(GrpcMethod::new( 669 669 - "rockbox.v1alpha1.LibraryService", 670 670 - "GetAlbum", 671 671 - )); 723 723 + req.extensions_mut() 724 724 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbum")); 672 725 self.inner.unary(req, path, codec).await 673 726 } 674 727 pub async fn get_artist( 675 728 &mut self, 676 729 request: impl tonic::IntoRequest<super::GetArtistRequest>, 677 677 - ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status> { 678 678 - self.inner.ready().await.map_err(|e| { 679 679 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 680 680 - })?; 730 730 + ) -> std::result::Result< 731 731 + tonic::Response<super::GetArtistResponse>, 732 732 + tonic::Status, 733 733 + > { 734 734 + self.inner 735 735 + .ready() 736 736 + .await 737 737 + .map_err(|e| { 738 738 + tonic::Status::unknown( 739 739 + format!("Service was not ready: {}", e.into()), 740 740 + ) 741 741 + })?; 681 742 let codec = tonic::codec::ProstCodec::default(); 682 682 - let path = 683 683 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtist"); 743 743 + let path = http::uri::PathAndQuery::from_static( 744 744 + "/rockbox.v1alpha1.LibraryService/GetArtist", 745 745 + ); 684 746 let mut req = request.into_request(); 685 685 - req.extensions_mut().insert(GrpcMethod::new( 686 686 - "rockbox.v1alpha1.LibraryService", 687 687 - "GetArtist", 688 688 - )); 747 747 + req.extensions_mut() 748 748 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtist")); 689 749 self.inner.unary(req, path, codec).await 690 750 } 691 751 pub async fn get_track( 692 752 &mut self, 693 753 request: impl tonic::IntoRequest<super::GetTrackRequest>, 694 694 - ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status> { 695 695 - self.inner.ready().await.map_err(|e| { 696 696 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 697 697 - })?; 754 754 + ) -> std::result::Result< 755 755 + tonic::Response<super::GetTrackResponse>, 756 756 + tonic::Status, 757 757 + > { 758 758 + self.inner 759 759 + .ready() 760 760 + .await 761 761 + .map_err(|e| { 762 762 + tonic::Status::unknown( 763 763 + format!("Service was not ready: {}", e.into()), 764 764 + ) 765 765 + })?; 698 766 let codec = tonic::codec::ProstCodec::default(); 699 699 - let path = 700 700 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTrack"); 767 767 + let path = http::uri::PathAndQuery::from_static( 768 768 + "/rockbox.v1alpha1.LibraryService/GetTrack", 769 769 + ); 701 770 let mut req = request.into_request(); 702 702 - req.extensions_mut().insert(GrpcMethod::new( 703 703 - "rockbox.v1alpha1.LibraryService", 704 704 - "GetTrack", 705 705 - )); 771 771 + req.extensions_mut() 772 772 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTrack")); 706 773 self.inner.unary(req, path, codec).await 707 774 } 708 775 pub async fn like_track( 709 776 &mut self, 710 777 request: impl tonic::IntoRequest<super::LikeTrackRequest>, 711 711 - ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status> { 712 712 - self.inner.ready().await.map_err(|e| { 713 713 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 714 714 - })?; 778 778 + ) -> std::result::Result< 779 779 + tonic::Response<super::LikeTrackResponse>, 780 780 + tonic::Status, 781 781 + > { 782 782 + self.inner 783 783 + .ready() 784 784 + .await 785 785 + .map_err(|e| { 786 786 + tonic::Status::unknown( 787 787 + format!("Service was not ready: {}", e.into()), 788 788 + ) 789 789 + })?; 715 790 let codec = tonic::codec::ProstCodec::default(); 716 716 - let path = 717 717 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeTrack"); 791 791 + let path = http::uri::PathAndQuery::from_static( 792 792 + "/rockbox.v1alpha1.LibraryService/LikeTrack", 793 793 + ); 718 794 let mut req = request.into_request(); 719 719 - req.extensions_mut().insert(GrpcMethod::new( 720 720 - "rockbox.v1alpha1.LibraryService", 721 721 - "LikeTrack", 722 722 - )); 795 795 + req.extensions_mut() 796 796 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeTrack")); 723 797 self.inner.unary(req, path, codec).await 724 798 } 725 799 pub async fn unlike_track( 726 800 &mut self, 727 801 request: impl tonic::IntoRequest<super::UnlikeTrackRequest>, 728 728 - ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status> 729 729 - { 730 730 - self.inner.ready().await.map_err(|e| { 731 731 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 732 732 - })?; 802 802 + ) -> std::result::Result< 803 803 + tonic::Response<super::UnlikeTrackResponse>, 804 804 + tonic::Status, 805 805 + > { 806 806 + self.inner 807 807 + .ready() 808 808 + .await 809 809 + .map_err(|e| { 810 810 + tonic::Status::unknown( 811 811 + format!("Service was not ready: {}", e.into()), 812 812 + ) 813 813 + })?; 733 814 let codec = tonic::codec::ProstCodec::default(); 734 815 let path = http::uri::PathAndQuery::from_static( 735 816 "/rockbox.v1alpha1.LibraryService/UnlikeTrack", 736 817 ); 737 818 let mut req = request.into_request(); 738 738 - req.extensions_mut().insert(GrpcMethod::new( 739 739 - "rockbox.v1alpha1.LibraryService", 740 740 - "UnlikeTrack", 741 741 - )); 819 819 + req.extensions_mut() 820 820 + .insert( 821 821 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeTrack"), 822 822 + ); 742 823 self.inner.unary(req, path, codec).await 743 824 } 744 825 pub async fn like_album( 745 826 &mut self, 746 827 request: impl tonic::IntoRequest<super::LikeAlbumRequest>, 747 747 - ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status> { 748 748 - self.inner.ready().await.map_err(|e| { 749 749 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 750 750 - })?; 828 828 + ) -> std::result::Result< 829 829 + tonic::Response<super::LikeAlbumResponse>, 830 830 + tonic::Status, 831 831 + > { 832 832 + self.inner 833 833 + .ready() 834 834 + .await 835 835 + .map_err(|e| { 836 836 + tonic::Status::unknown( 837 837 + format!("Service was not ready: {}", e.into()), 838 838 + ) 839 839 + })?; 751 840 let codec = tonic::codec::ProstCodec::default(); 752 752 - let path = 753 753 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeAlbum"); 841 841 + let path = http::uri::PathAndQuery::from_static( 842 842 + "/rockbox.v1alpha1.LibraryService/LikeAlbum", 843 843 + ); 754 844 let mut req = request.into_request(); 755 755 - req.extensions_mut().insert(GrpcMethod::new( 756 756 - "rockbox.v1alpha1.LibraryService", 757 757 - "LikeAlbum", 758 758 - )); 845 845 + req.extensions_mut() 846 846 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeAlbum")); 759 847 self.inner.unary(req, path, codec).await 760 848 } 761 849 pub async fn unlike_album( 762 850 &mut self, 763 851 request: impl tonic::IntoRequest<super::UnlikeAlbumRequest>, 764 764 - ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status> 765 765 - { 766 766 - self.inner.ready().await.map_err(|e| { 767 767 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 768 768 - })?; 852 852 + ) -> std::result::Result< 853 853 + tonic::Response<super::UnlikeAlbumResponse>, 854 854 + tonic::Status, 855 855 + > { 856 856 + self.inner 857 857 + .ready() 858 858 + .await 859 859 + .map_err(|e| { 860 860 + tonic::Status::unknown( 861 861 + format!("Service was not ready: {}", e.into()), 862 862 + ) 863 863 + })?; 769 864 let codec = tonic::codec::ProstCodec::default(); 770 865 let path = http::uri::PathAndQuery::from_static( 771 866 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum", 772 867 ); 773 868 let mut req = request.into_request(); 774 774 - req.extensions_mut().insert(GrpcMethod::new( 775 775 - "rockbox.v1alpha1.LibraryService", 776 776 - "UnlikeAlbum", 777 777 - )); 869 869 + req.extensions_mut() 870 870 + .insert( 871 871 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeAlbum"), 872 872 + ); 778 873 self.inner.unary(req, path, codec).await 779 874 } 780 875 pub async fn get_liked_tracks( 781 876 &mut self, 782 877 request: impl tonic::IntoRequest<super::GetLikedTracksRequest>, 783 783 - ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status> 784 784 - { 785 785 - self.inner.ready().await.map_err(|e| { 786 786 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 787 787 - })?; 878 878 + ) -> std::result::Result< 879 879 + tonic::Response<super::GetLikedTracksResponse>, 880 880 + tonic::Status, 881 881 + > { 882 882 + self.inner 883 883 + .ready() 884 884 + .await 885 885 + .map_err(|e| { 886 886 + tonic::Status::unknown( 887 887 + format!("Service was not ready: {}", e.into()), 888 888 + ) 889 889 + })?; 788 890 let codec = tonic::codec::ProstCodec::default(); 789 891 let path = http::uri::PathAndQuery::from_static( 790 892 "/rockbox.v1alpha1.LibraryService/GetLikedTracks", 791 893 ); 792 894 let mut req = request.into_request(); 793 793 - req.extensions_mut().insert(GrpcMethod::new( 794 794 - "rockbox.v1alpha1.LibraryService", 795 795 - "GetLikedTracks", 796 796 - )); 895 895 + req.extensions_mut() 896 896 + .insert( 897 897 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedTracks"), 898 898 + ); 797 899 self.inner.unary(req, path, codec).await 798 900 } 799 901 pub async fn get_liked_albums( 800 902 &mut self, 801 903 request: impl tonic::IntoRequest<super::GetLikedAlbumsRequest>, 802 802 - ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status> 803 803 - { 804 804 - self.inner.ready().await.map_err(|e| { 805 805 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 806 806 - })?; 904 904 + ) -> std::result::Result< 905 905 + tonic::Response<super::GetLikedAlbumsResponse>, 906 906 + tonic::Status, 907 907 + > { 908 908 + self.inner 909 909 + .ready() 910 910 + .await 911 911 + .map_err(|e| { 912 912 + tonic::Status::unknown( 913 913 + format!("Service was not ready: {}", e.into()), 914 914 + ) 915 915 + })?; 807 916 let codec = tonic::codec::ProstCodec::default(); 808 917 let path = http::uri::PathAndQuery::from_static( 809 918 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums", 810 919 ); 811 920 let mut req = request.into_request(); 812 812 - req.extensions_mut().insert(GrpcMethod::new( 813 813 - "rockbox.v1alpha1.LibraryService", 814 814 - "GetLikedAlbums", 815 815 - )); 921 921 + req.extensions_mut() 922 922 + .insert( 923 923 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedAlbums"), 924 924 + ); 816 925 self.inner.unary(req, path, codec).await 817 926 } 818 927 pub async fn scan_library( 819 928 &mut self, 820 929 request: impl tonic::IntoRequest<super::ScanLibraryRequest>, 821 821 - ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status> 822 822 - { 823 823 - self.inner.ready().await.map_err(|e| { 824 824 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 825 825 - })?; 930 930 + ) -> std::result::Result< 931 931 + tonic::Response<super::ScanLibraryResponse>, 932 932 + tonic::Status, 933 933 + > { 934 934 + self.inner 935 935 + .ready() 936 936 + .await 937 937 + .map_err(|e| { 938 938 + tonic::Status::unknown( 939 939 + format!("Service was not ready: {}", e.into()), 940 940 + ) 941 941 + })?; 826 942 let codec = tonic::codec::ProstCodec::default(); 827 943 let path = http::uri::PathAndQuery::from_static( 828 944 "/rockbox.v1alpha1.LibraryService/ScanLibrary", 829 945 ); 830 946 let mut req = request.into_request(); 831 831 - req.extensions_mut().insert(GrpcMethod::new( 832 832 - "rockbox.v1alpha1.LibraryService", 833 833 - "ScanLibrary", 834 834 - )); 947 947 + req.extensions_mut() 948 948 + .insert( 949 949 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "ScanLibrary"), 950 950 + ); 835 951 self.inner.unary(req, path, codec).await 836 952 } 837 953 pub async fn search( 838 954 &mut self, 839 955 request: impl tonic::IntoRequest<super::SearchRequest>, 840 956 ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> { 841 841 - self.inner.ready().await.map_err(|e| { 842 842 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 843 843 - })?; 957 957 + self.inner 958 958 + .ready() 959 959 + .await 960 960 + .map_err(|e| { 961 961 + tonic::Status::unknown( 962 962 + format!("Service was not ready: {}", e.into()), 963 963 + ) 964 964 + })?; 844 965 let codec = tonic::codec::ProstCodec::default(); 845 845 - let path = 846 846 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/Search"); 966 966 + let path = http::uri::PathAndQuery::from_static( 967 967 + "/rockbox.v1alpha1.LibraryService/Search", 968 968 + ); 847 969 let mut req = request.into_request(); 848 970 req.extensions_mut() 849 971 .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "Search")); ··· 858 980 dead_code, 859 981 missing_docs, 860 982 clippy::wildcard_imports, 861 861 - clippy::let_unit_value 983 983 + clippy::let_unit_value, 862 984 )] 863 985 use tonic::codegen::*; 864 986 /// Generated trait containing gRPC methods that should be implemented for use with LibraryServiceServer. ··· 867 989 async fn get_albums( 868 990 &self, 869 991 request: tonic::Request<super::GetAlbumsRequest>, 870 870 - ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status>; 992 992 + ) -> std::result::Result< 993 993 + tonic::Response<super::GetAlbumsResponse>, 994 994 + tonic::Status, 995 995 + >; 871 996 async fn get_artists( 872 997 &self, 873 998 request: tonic::Request<super::GetArtistsRequest>, 874 874 - ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status>; 999 999 + ) -> std::result::Result< 1000 1000 + tonic::Response<super::GetArtistsResponse>, 1001 1001 + tonic::Status, 1002 1002 + >; 875 1003 async fn get_tracks( 876 1004 &self, 877 1005 request: tonic::Request<super::GetTracksRequest>, 878 878 - ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status>; 1006 1006 + ) -> std::result::Result< 1007 1007 + tonic::Response<super::GetTracksResponse>, 1008 1008 + tonic::Status, 1009 1009 + >; 879 1010 async fn get_album( 880 1011 &self, 881 1012 request: tonic::Request<super::GetAlbumRequest>, 882 882 - ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status>; 1013 1013 + ) -> std::result::Result< 1014 1014 + tonic::Response<super::GetAlbumResponse>, 1015 1015 + tonic::Status, 1016 1016 + >; 883 1017 async fn get_artist( 884 1018 &self, 885 1019 request: tonic::Request<super::GetArtistRequest>, 886 886 - ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status>; 1020 1020 + ) -> std::result::Result< 1021 1021 + tonic::Response<super::GetArtistResponse>, 1022 1022 + tonic::Status, 1023 1023 + >; 887 1024 async fn get_track( 888 1025 &self, 889 1026 request: tonic::Request<super::GetTrackRequest>, 890 890 - ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status>; 1027 1027 + ) -> std::result::Result< 1028 1028 + tonic::Response<super::GetTrackResponse>, 1029 1029 + tonic::Status, 1030 1030 + >; 891 1031 async fn like_track( 892 1032 &self, 893 1033 request: tonic::Request<super::LikeTrackRequest>, 894 894 - ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status>; 1034 1034 + ) -> std::result::Result< 1035 1035 + tonic::Response<super::LikeTrackResponse>, 1036 1036 + tonic::Status, 1037 1037 + >; 895 1038 async fn unlike_track( 896 1039 &self, 897 1040 request: tonic::Request<super::UnlikeTrackRequest>, 898 898 - ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status>; 1041 1041 + ) -> std::result::Result< 1042 1042 + tonic::Response<super::UnlikeTrackResponse>, 1043 1043 + tonic::Status, 1044 1044 + >; 899 1045 async fn like_album( 900 1046 &self, 901 1047 request: tonic::Request<super::LikeAlbumRequest>, 902 902 - ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status>; 1048 1048 + ) -> std::result::Result< 1049 1049 + tonic::Response<super::LikeAlbumResponse>, 1050 1050 + tonic::Status, 1051 1051 + >; 903 1052 async fn unlike_album( 904 1053 &self, 905 1054 request: tonic::Request<super::UnlikeAlbumRequest>, 906 906 - ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status>; 1055 1055 + ) -> std::result::Result< 1056 1056 + tonic::Response<super::UnlikeAlbumResponse>, 1057 1057 + tonic::Status, 1058 1058 + >; 907 1059 async fn get_liked_tracks( 908 1060 &self, 909 1061 request: tonic::Request<super::GetLikedTracksRequest>, 910 910 - ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status>; 1062 1062 + ) -> std::result::Result< 1063 1063 + tonic::Response<super::GetLikedTracksResponse>, 1064 1064 + tonic::Status, 1065 1065 + >; 911 1066 async fn get_liked_albums( 912 1067 &self, 913 1068 request: tonic::Request<super::GetLikedAlbumsRequest>, 914 914 - ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status>; 1069 1069 + ) -> std::result::Result< 1070 1070 + tonic::Response<super::GetLikedAlbumsResponse>, 1071 1071 + tonic::Status, 1072 1072 + >; 915 1073 async fn scan_library( 916 1074 &self, 917 1075 request: tonic::Request<super::ScanLibraryRequest>, 918 918 - ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>; 1076 1076 + ) -> std::result::Result< 1077 1077 + tonic::Response<super::ScanLibraryResponse>, 1078 1078 + tonic::Status, 1079 1079 + >; 919 1080 async fn search( 920 1081 &self, 921 1082 request: tonic::Request<super::SearchRequest>, ··· 942 1103 max_encoding_message_size: None, 943 1104 } 944 1105 } 945 945 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1106 1106 + pub fn with_interceptor<F>( 1107 1107 + inner: T, 1108 1108 + interceptor: F, 1109 1109 + ) -> InterceptedService<Self, F> 946 1110 where 947 1111 F: tonic::service::Interceptor, 948 1112 { ··· 997 1161 "/rockbox.v1alpha1.LibraryService/GetAlbums" => { 998 1162 #[allow(non_camel_case_types)] 999 1163 struct GetAlbumsSvc<T: LibraryService>(pub Arc<T>); 1000 1000 - impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumsRequest> for GetAlbumsSvc<T> { 1164 1164 + impl< 1165 1165 + T: LibraryService, 1166 1166 + > tonic::server::UnaryService<super::GetAlbumsRequest> 1167 1167 + for GetAlbumsSvc<T> { 1001 1168 type Response = super::GetAlbumsResponse; 1002 1002 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1169 1169 + type Future = BoxFuture< 1170 1170 + tonic::Response<Self::Response>, 1171 1171 + tonic::Status, 1172 1172 + >; 1003 1173 fn call( 1004 1174 &mut self, 1005 1175 request: tonic::Request<super::GetAlbumsRequest>, ··· 1036 1206 "/rockbox.v1alpha1.LibraryService/GetArtists" => { 1037 1207 #[allow(non_camel_case_types)] 1038 1208 struct GetArtistsSvc<T: LibraryService>(pub Arc<T>); 1039 1039 - impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistsRequest> for GetArtistsSvc<T> { 1209 1209 + impl< 1210 1210 + T: LibraryService, 1211 1211 + > tonic::server::UnaryService<super::GetArtistsRequest> 1212 1212 + for GetArtistsSvc<T> { 1040 1213 type Response = super::GetArtistsResponse; 1041 1041 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1214 1214 + type Future = BoxFuture< 1215 1215 + tonic::Response<Self::Response>, 1216 1216 + tonic::Status, 1217 1217 + >; 1042 1218 fn call( 1043 1219 &mut self, 1044 1220 request: tonic::Request<super::GetArtistsRequest>, ··· 1075 1251 "/rockbox.v1alpha1.LibraryService/GetTracks" => { 1076 1252 #[allow(non_camel_case_types)] 1077 1253 struct GetTracksSvc<T: LibraryService>(pub Arc<T>); 1078 1078 - impl<T: LibraryService> tonic::server::UnaryService<super::GetTracksRequest> for GetTracksSvc<T> { 1254 1254 + impl< 1255 1255 + T: LibraryService, 1256 1256 + > tonic::server::UnaryService<super::GetTracksRequest> 1257 1257 + for GetTracksSvc<T> { 1079 1258 type Response = super::GetTracksResponse; 1080 1080 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1259 1259 + type Future = BoxFuture< 1260 1260 + tonic::Response<Self::Response>, 1261 1261 + tonic::Status, 1262 1262 + >; 1081 1263 fn call( 1082 1264 &mut self, 1083 1265 request: tonic::Request<super::GetTracksRequest>, ··· 1114 1296 "/rockbox.v1alpha1.LibraryService/GetAlbum" => { 1115 1297 #[allow(non_camel_case_types)] 1116 1298 struct GetAlbumSvc<T: LibraryService>(pub Arc<T>); 1117 1117 - impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumRequest> for GetAlbumSvc<T> { 1299 1299 + impl< 1300 1300 + T: LibraryService, 1301 1301 + > tonic::server::UnaryService<super::GetAlbumRequest> 1302 1302 + for GetAlbumSvc<T> { 1118 1303 type Response = super::GetAlbumResponse; 1119 1119 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1304 1304 + type Future = BoxFuture< 1305 1305 + tonic::Response<Self::Response>, 1306 1306 + tonic::Status, 1307 1307 + >; 1120 1308 fn call( 1121 1309 &mut self, 1122 1310 request: tonic::Request<super::GetAlbumRequest>, ··· 1153 1341 "/rockbox.v1alpha1.LibraryService/GetArtist" => { 1154 1342 #[allow(non_camel_case_types)] 1155 1343 struct GetArtistSvc<T: LibraryService>(pub Arc<T>); 1156 1156 - impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistRequest> for GetArtistSvc<T> { 1344 1344 + impl< 1345 1345 + T: LibraryService, 1346 1346 + > tonic::server::UnaryService<super::GetArtistRequest> 1347 1347 + for GetArtistSvc<T> { 1157 1348 type Response = super::GetArtistResponse; 1158 1158 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1349 1349 + type Future = BoxFuture< 1350 1350 + tonic::Response<Self::Response>, 1351 1351 + tonic::Status, 1352 1352 + >; 1159 1353 fn call( 1160 1354 &mut self, 1161 1355 request: tonic::Request<super::GetArtistRequest>, ··· 1192 1386 "/rockbox.v1alpha1.LibraryService/GetTrack" => { 1193 1387 #[allow(non_camel_case_types)] 1194 1388 struct GetTrackSvc<T: LibraryService>(pub Arc<T>); 1195 1195 - impl<T: LibraryService> tonic::server::UnaryService<super::GetTrackRequest> for GetTrackSvc<T> { 1389 1389 + impl< 1390 1390 + T: LibraryService, 1391 1391 + > tonic::server::UnaryService<super::GetTrackRequest> 1392 1392 + for GetTrackSvc<T> { 1196 1393 type Response = super::GetTrackResponse; 1197 1197 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1394 1394 + type Future = BoxFuture< 1395 1395 + tonic::Response<Self::Response>, 1396 1396 + tonic::Status, 1397 1397 + >; 1198 1398 fn call( 1199 1399 &mut self, 1200 1400 request: tonic::Request<super::GetTrackRequest>, ··· 1231 1431 "/rockbox.v1alpha1.LibraryService/LikeTrack" => { 1232 1432 #[allow(non_camel_case_types)] 1233 1433 struct LikeTrackSvc<T: LibraryService>(pub Arc<T>); 1234 1234 - impl<T: LibraryService> tonic::server::UnaryService<super::LikeTrackRequest> for LikeTrackSvc<T> { 1434 1434 + impl< 1435 1435 + T: LibraryService, 1436 1436 + > tonic::server::UnaryService<super::LikeTrackRequest> 1437 1437 + for LikeTrackSvc<T> { 1235 1438 type Response = super::LikeTrackResponse; 1236 1236 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1439 1439 + type Future = BoxFuture< 1440 1440 + tonic::Response<Self::Response>, 1441 1441 + tonic::Status, 1442 1442 + >; 1237 1443 fn call( 1238 1444 &mut self, 1239 1445 request: tonic::Request<super::LikeTrackRequest>, ··· 1270 1476 "/rockbox.v1alpha1.LibraryService/UnlikeTrack" => { 1271 1477 #[allow(non_camel_case_types)] 1272 1478 struct UnlikeTrackSvc<T: LibraryService>(pub Arc<T>); 1273 1273 - impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeTrackRequest> 1274 1274 - for UnlikeTrackSvc<T> 1275 1275 - { 1479 1479 + impl< 1480 1480 + T: LibraryService, 1481 1481 + > tonic::server::UnaryService<super::UnlikeTrackRequest> 1482 1482 + for UnlikeTrackSvc<T> { 1276 1483 type Response = super::UnlikeTrackResponse; 1277 1277 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1484 1484 + type Future = BoxFuture< 1485 1485 + tonic::Response<Self::Response>, 1486 1486 + tonic::Status, 1487 1487 + >; 1278 1488 fn call( 1279 1489 &mut self, 1280 1490 request: tonic::Request<super::UnlikeTrackRequest>, ··· 1311 1521 "/rockbox.v1alpha1.LibraryService/LikeAlbum" => { 1312 1522 #[allow(non_camel_case_types)] 1313 1523 struct LikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1314 1314 - impl<T: LibraryService> tonic::server::UnaryService<super::LikeAlbumRequest> for LikeAlbumSvc<T> { 1524 1524 + impl< 1525 1525 + T: LibraryService, 1526 1526 + > tonic::server::UnaryService<super::LikeAlbumRequest> 1527 1527 + for LikeAlbumSvc<T> { 1315 1528 type Response = super::LikeAlbumResponse; 1316 1316 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1529 1529 + type Future = BoxFuture< 1530 1530 + tonic::Response<Self::Response>, 1531 1531 + tonic::Status, 1532 1532 + >; 1317 1533 fn call( 1318 1534 &mut self, 1319 1535 request: tonic::Request<super::LikeAlbumRequest>, ··· 1350 1566 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum" => { 1351 1567 #[allow(non_camel_case_types)] 1352 1568 struct UnlikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1353 1353 - impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeAlbumRequest> 1354 1354 - for UnlikeAlbumSvc<T> 1355 1355 - { 1569 1569 + impl< 1570 1570 + T: LibraryService, 1571 1571 + > tonic::server::UnaryService<super::UnlikeAlbumRequest> 1572 1572 + for UnlikeAlbumSvc<T> { 1356 1573 type Response = super::UnlikeAlbumResponse; 1357 1357 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1574 1574 + type Future = BoxFuture< 1575 1575 + tonic::Response<Self::Response>, 1576 1576 + tonic::Status, 1577 1577 + >; 1358 1578 fn call( 1359 1579 &mut self, 1360 1580 request: tonic::Request<super::UnlikeAlbumRequest>, ··· 1391 1611 "/rockbox.v1alpha1.LibraryService/GetLikedTracks" => { 1392 1612 #[allow(non_camel_case_types)] 1393 1613 struct GetLikedTracksSvc<T: LibraryService>(pub Arc<T>); 1394 1394 - impl<T: LibraryService> 1395 1395 - tonic::server::UnaryService<super::GetLikedTracksRequest> 1396 1396 - for GetLikedTracksSvc<T> 1397 1397 - { 1614 1614 + impl< 1615 1615 + T: LibraryService, 1616 1616 + > tonic::server::UnaryService<super::GetLikedTracksRequest> 1617 1617 + for GetLikedTracksSvc<T> { 1398 1618 type Response = super::GetLikedTracksResponse; 1399 1399 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1619 1619 + type Future = BoxFuture< 1620 1620 + tonic::Response<Self::Response>, 1621 1621 + tonic::Status, 1622 1622 + >; 1400 1623 fn call( 1401 1624 &mut self, 1402 1625 request: tonic::Request<super::GetLikedTracksRequest>, 1403 1626 ) -> Self::Future { 1404 1627 let inner = Arc::clone(&self.0); 1405 1628 let fut = async move { 1406 1406 - <T as LibraryService>::get_liked_tracks(&inner, request).await 1629 1629 + <T as LibraryService>::get_liked_tracks(&inner, request) 1630 1630 + .await 1407 1631 }; 1408 1632 Box::pin(fut) 1409 1633 } ··· 1433 1657 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums" => { 1434 1658 #[allow(non_camel_case_types)] 1435 1659 struct GetLikedAlbumsSvc<T: LibraryService>(pub Arc<T>); 1436 1436 - impl<T: LibraryService> 1437 1437 - tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1438 1438 - for GetLikedAlbumsSvc<T> 1439 1439 - { 1660 1660 + impl< 1661 1661 + T: LibraryService, 1662 1662 + > tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1663 1663 + for GetLikedAlbumsSvc<T> { 1440 1664 type Response = super::GetLikedAlbumsResponse; 1441 1441 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1665 1665 + type Future = BoxFuture< 1666 1666 + tonic::Response<Self::Response>, 1667 1667 + tonic::Status, 1668 1668 + >; 1442 1669 fn call( 1443 1670 &mut self, 1444 1671 request: tonic::Request<super::GetLikedAlbumsRequest>, 1445 1672 ) -> Self::Future { 1446 1673 let inner = Arc::clone(&self.0); 1447 1674 let fut = async move { 1448 1448 - <T as LibraryService>::get_liked_albums(&inner, request).await 1675 1675 + <T as LibraryService>::get_liked_albums(&inner, request) 1676 1676 + .await 1449 1677 }; 1450 1678 Box::pin(fut) 1451 1679 } ··· 1475 1703 "/rockbox.v1alpha1.LibraryService/ScanLibrary" => { 1476 1704 #[allow(non_camel_case_types)] 1477 1705 struct ScanLibrarySvc<T: LibraryService>(pub Arc<T>); 1478 1478 - impl<T: LibraryService> tonic::server::UnaryService<super::ScanLibraryRequest> 1479 1479 - for ScanLibrarySvc<T> 1480 1480 - { 1706 1706 + impl< 1707 1707 + T: LibraryService, 1708 1708 + > tonic::server::UnaryService<super::ScanLibraryRequest> 1709 1709 + for ScanLibrarySvc<T> { 1481 1710 type Response = super::ScanLibraryResponse; 1482 1482 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1711 1711 + type Future = BoxFuture< 1712 1712 + tonic::Response<Self::Response>, 1713 1713 + tonic::Status, 1714 1714 + >; 1483 1715 fn call( 1484 1716 &mut self, 1485 1717 request: tonic::Request<super::ScanLibraryRequest>, ··· 1516 1748 "/rockbox.v1alpha1.LibraryService/Search" => { 1517 1749 #[allow(non_camel_case_types)] 1518 1750 struct SearchSvc<T: LibraryService>(pub Arc<T>); 1519 1519 - impl<T: LibraryService> tonic::server::UnaryService<super::SearchRequest> for SearchSvc<T> { 1751 1751 + impl< 1752 1752 + T: LibraryService, 1753 1753 + > tonic::server::UnaryService<super::SearchRequest> 1754 1754 + for SearchSvc<T> { 1520 1755 type Response = super::SearchResponse; 1521 1521 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1756 1756 + type Future = BoxFuture< 1757 1757 + tonic::Response<Self::Response>, 1758 1758 + tonic::Status, 1759 1759 + >; 1522 1760 fn call( 1523 1761 &mut self, 1524 1762 request: tonic::Request<super::SearchRequest>, 1525 1763 ) -> Self::Future { 1526 1764 let inner = Arc::clone(&self.0); 1527 1527 - let fut = 1528 1528 - async move { <T as LibraryService>::search(&inner, request).await }; 1765 1765 + let fut = async move { 1766 1766 + <T as LibraryService>::search(&inner, request).await 1767 1767 + }; 1529 1768 Box::pin(fut) 1530 1769 } 1531 1770 } ··· 1551 1790 }; 1552 1791 Box::pin(fut) 1553 1792 } 1554 1554 - _ => Box::pin(async move { 1555 1555 - let mut response = http::Response::new(empty_body()); 1556 1556 - let headers = response.headers_mut(); 1557 1557 - headers.insert( 1558 1558 - tonic::Status::GRPC_STATUS, 1559 1559 - (tonic::Code::Unimplemented as i32).into(), 1560 1560 - ); 1561 1561 - headers.insert( 1562 1562 - http::header::CONTENT_TYPE, 1563 1563 - tonic::metadata::GRPC_CONTENT_TYPE, 1564 1564 - ); 1565 1565 - Ok(response) 1566 1566 - }), 1793 1793 + _ => { 1794 1794 + Box::pin(async move { 1795 1795 + let mut response = http::Response::new(empty_body()); 1796 1796 + let headers = response.headers_mut(); 1797 1797 + headers 1798 1798 + .insert( 1799 1799 + tonic::Status::GRPC_STATUS, 1800 1800 + (tonic::Code::Unimplemented as i32).into(), 1801 1801 + ); 1802 1802 + headers 1803 1803 + .insert( 1804 1804 + http::header::CONTENT_TYPE, 1805 1805 + tonic::metadata::GRPC_CONTENT_TYPE, 1806 1806 + ); 1807 1807 + Ok(response) 1808 1808 + }) 1809 1809 + } 1567 1810 } 1568 1811 } 1569 1812 } ··· 1592 1835 dead_code, 1593 1836 missing_docs, 1594 1837 clippy::wildcard_imports, 1595 1595 - clippy::let_unit_value 1838 1838 + clippy::let_unit_value, 1596 1839 )] 1597 1597 - use tonic::codegen::http::Uri; 1598 1840 use tonic::codegen::*; 1841 1841 + use tonic::codegen::http::Uri; 1599 1842 #[derive(Debug, Clone)] 1600 1843 pub struct MetadataServiceClient<T> { 1601 1844 inner: tonic::client::Grpc<T>, ··· 1639 1882 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 1640 1883 >, 1641 1884 >, 1642 1642 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 1643 1643 - Into<StdError> + std::marker::Send + std::marker::Sync, 1885 1885 + <T as tonic::codegen::Service< 1886 1886 + http::Request<tonic::body::BoxBody>, 1887 1887 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 1644 1888 { 1645 1889 MetadataServiceClient::new(InterceptedService::new(inner, interceptor)) 1646 1890 } ··· 1684 1928 dead_code, 1685 1929 missing_docs, 1686 1930 clippy::wildcard_imports, 1687 1687 - clippy::let_unit_value 1931 1931 + clippy::let_unit_value, 1688 1932 )] 1689 1933 use tonic::codegen::*; 1690 1934 /// Generated trait containing gRPC methods that should be implemented for use with MetadataServiceServer. ··· 1711 1955 max_encoding_message_size: None, 1712 1956 } 1713 1957 } 1714 1714 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1958 1958 + pub fn with_interceptor<F>( 1959 1959 + inner: T, 1960 1960 + interceptor: F, 1961 1961 + ) -> InterceptedService<Self, F> 1715 1962 where 1716 1963 F: tonic::service::Interceptor, 1717 1964 { ··· 1763 2010 } 1764 2011 fn call(&mut self, req: http::Request<B>) -> Self::Future { 1765 2012 match req.uri().path() { 1766 1766 - _ => Box::pin(async move { 1767 1767 - let mut response = http::Response::new(empty_body()); 1768 1768 - let headers = response.headers_mut(); 1769 1769 - headers.insert( 1770 1770 - tonic::Status::GRPC_STATUS, 1771 1771 - (tonic::Code::Unimplemented as i32).into(), 1772 1772 - ); 1773 1773 - headers.insert( 1774 1774 - http::header::CONTENT_TYPE, 1775 1775 - tonic::metadata::GRPC_CONTENT_TYPE, 1776 1776 - ); 1777 1777 - Ok(response) 1778 1778 - }), 2013 2013 + _ => { 2014 2014 + Box::pin(async move { 2015 2015 + let mut response = http::Response::new(empty_body()); 2016 2016 + let headers = response.headers_mut(); 2017 2017 + headers 2018 2018 + .insert( 2019 2019 + tonic::Status::GRPC_STATUS, 2020 2020 + (tonic::Code::Unimplemented as i32).into(), 2021 2021 + ); 2022 2022 + headers 2023 2023 + .insert( 2024 2024 + http::header::CONTENT_TYPE, 2025 2025 + tonic::metadata::GRPC_CONTENT_TYPE, 2026 2026 + ); 2027 2027 + Ok(response) 2028 2028 + }) 2029 2029 + } 1779 2030 } 1780 2031 } 1781 2032 } ··· 2048 2299 dead_code, 2049 2300 missing_docs, 2050 2301 clippy::wildcard_imports, 2051 2051 - clippy::let_unit_value 2302 2302 + clippy::let_unit_value, 2052 2303 )] 2053 2053 - use tonic::codegen::http::Uri; 2054 2304 use tonic::codegen::*; 2305 2305 + use tonic::codegen::http::Uri; 2055 2306 #[derive(Debug, Clone)] 2056 2307 pub struct PlaybackServiceClient<T> { 2057 2308 inner: tonic::client::Grpc<T>, ··· 2095 2346 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 2096 2347 >, 2097 2348 >, 2098 2098 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 2099 2099 - Into<StdError> + std::marker::Send + std::marker::Sync, 2349 2349 + <T as tonic::codegen::Service< 2350 2350 + http::Request<tonic::body::BoxBody>, 2351 2351 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 2100 2352 { 2101 2353 PlaybackServiceClient::new(InterceptedService::new(inner, interceptor)) 2102 2354 } ··· 2135 2387 &mut self, 2136 2388 request: impl tonic::IntoRequest<super::PlayRequest>, 2137 2389 ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> { 2138 2138 - self.inner.ready().await.map_err(|e| { 2139 2139 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2140 2140 - })?; 2390 2390 + self.inner 2391 2391 + .ready() 2392 2392 + .await 2393 2393 + .map_err(|e| { 2394 2394 + tonic::Status::unknown( 2395 2395 + format!("Service was not ready: {}", e.into()), 2396 2396 + ) 2397 2397 + })?; 2141 2398 let codec = tonic::codec::ProstCodec::default(); 2142 2142 - let path = 2143 2143 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Play"); 2399 2399 + let path = http::uri::PathAndQuery::from_static( 2400 2400 + "/rockbox.v1alpha1.PlaybackService/Play", 2401 2401 + ); 2144 2402 let mut req = request.into_request(); 2145 2403 req.extensions_mut() 2146 2404 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Play")); ··· 2150 2408 &mut self, 2151 2409 request: impl tonic::IntoRequest<super::PauseRequest>, 2152 2410 ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> { 2153 2153 - self.inner.ready().await.map_err(|e| { 2154 2154 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2155 2155 - })?; 2411 2411 + self.inner 2412 2412 + .ready() 2413 2413 + .await 2414 2414 + .map_err(|e| { 2415 2415 + tonic::Status::unknown( 2416 2416 + format!("Service was not ready: {}", e.into()), 2417 2417 + ) 2418 2418 + })?; 2156 2419 let codec = tonic::codec::ProstCodec::default(); 2157 2157 - let path = 2158 2158 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Pause"); 2420 2420 + let path = http::uri::PathAndQuery::from_static( 2421 2421 + "/rockbox.v1alpha1.PlaybackService/Pause", 2422 2422 + ); 2159 2423 let mut req = request.into_request(); 2160 2424 req.extensions_mut() 2161 2425 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Pause")); ··· 2164 2428 pub async fn play_or_pause( 2165 2429 &mut self, 2166 2430 request: impl tonic::IntoRequest<super::PlayOrPauseRequest>, 2167 2167 - ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status> 2168 2168 - { 2169 2169 - self.inner.ready().await.map_err(|e| { 2170 2170 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2171 2171 - })?; 2431 2431 + ) -> std::result::Result< 2432 2432 + tonic::Response<super::PlayOrPauseResponse>, 2433 2433 + tonic::Status, 2434 2434 + > { 2435 2435 + self.inner 2436 2436 + .ready() 2437 2437 + .await 2438 2438 + .map_err(|e| { 2439 2439 + tonic::Status::unknown( 2440 2440 + format!("Service was not ready: {}", e.into()), 2441 2441 + ) 2442 2442 + })?; 2172 2443 let codec = tonic::codec::ProstCodec::default(); 2173 2444 let path = http::uri::PathAndQuery::from_static( 2174 2445 "/rockbox.v1alpha1.PlaybackService/PlayOrPause", 2175 2446 ); 2176 2447 let mut req = request.into_request(); 2177 2177 - req.extensions_mut().insert(GrpcMethod::new( 2178 2178 - "rockbox.v1alpha1.PlaybackService", 2179 2179 - "PlayOrPause", 2180 2180 - )); 2448 2448 + req.extensions_mut() 2449 2449 + .insert( 2450 2450 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayOrPause"), 2451 2451 + ); 2181 2452 self.inner.unary(req, path, codec).await 2182 2453 } 2183 2454 pub async fn resume( 2184 2455 &mut self, 2185 2456 request: impl tonic::IntoRequest<super::ResumeRequest>, 2186 2457 ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> { 2187 2187 - self.inner.ready().await.map_err(|e| { 2188 2188 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2189 2189 - })?; 2458 2458 + self.inner 2459 2459 + .ready() 2460 2460 + .await 2461 2461 + .map_err(|e| { 2462 2462 + tonic::Status::unknown( 2463 2463 + format!("Service was not ready: {}", e.into()), 2464 2464 + ) 2465 2465 + })?; 2190 2466 let codec = tonic::codec::ProstCodec::default(); 2191 2191 - let path = 2192 2192 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Resume"); 2467 2467 + let path = http::uri::PathAndQuery::from_static( 2468 2468 + "/rockbox.v1alpha1.PlaybackService/Resume", 2469 2469 + ); 2193 2470 let mut req = request.into_request(); 2194 2194 - req.extensions_mut().insert(GrpcMethod::new( 2195 2195 - "rockbox.v1alpha1.PlaybackService", 2196 2196 - "Resume", 2197 2197 - )); 2471 2471 + req.extensions_mut() 2472 2472 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Resume")); 2198 2473 self.inner.unary(req, path, codec).await 2199 2474 } 2200 2475 pub async fn next( 2201 2476 &mut self, 2202 2477 request: impl tonic::IntoRequest<super::NextRequest>, 2203 2478 ) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status> { 2204 2204 - self.inner.ready().await.map_err(|e| { 2205 2205 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2206 2206 - })?; 2479 2479 + self.inner 2480 2480 + .ready() 2481 2481 + .await 2482 2482 + .map_err(|e| { 2483 2483 + tonic::Status::unknown( 2484 2484 + format!("Service was not ready: {}", e.into()), 2485 2485 + ) 2486 2486 + })?; 2207 2487 let codec = tonic::codec::ProstCodec::default(); 2208 2208 - let path = 2209 2209 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Next"); 2488 2488 + let path = http::uri::PathAndQuery::from_static( 2489 2489 + "/rockbox.v1alpha1.PlaybackService/Next", 2490 2490 + ); 2210 2491 let mut req = request.into_request(); 2211 2492 req.extensions_mut() 2212 2493 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Next")); ··· 2215 2496 pub async fn previous( 2216 2497 &mut self, 2217 2498 request: impl tonic::IntoRequest<super::PreviousRequest>, 2218 2218 - ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status> { 2219 2219 - self.inner.ready().await.map_err(|e| { 2220 2220 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2221 2221 - })?; 2499 2499 + ) -> std::result::Result< 2500 2500 + tonic::Response<super::PreviousResponse>, 2501 2501 + tonic::Status, 2502 2502 + > { 2503 2503 + self.inner 2504 2504 + .ready() 2505 2505 + .await 2506 2506 + .map_err(|e| { 2507 2507 + tonic::Status::unknown( 2508 2508 + format!("Service was not ready: {}", e.into()), 2509 2509 + ) 2510 2510 + })?; 2222 2511 let codec = tonic::codec::ProstCodec::default(); 2223 2223 - let path = 2224 2224 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Previous"); 2512 2512 + let path = http::uri::PathAndQuery::from_static( 2513 2513 + "/rockbox.v1alpha1.PlaybackService/Previous", 2514 2514 + ); 2225 2515 let mut req = request.into_request(); 2226 2226 - req.extensions_mut().insert(GrpcMethod::new( 2227 2227 - "rockbox.v1alpha1.PlaybackService", 2228 2228 - "Previous", 2229 2229 - )); 2516 2516 + req.extensions_mut() 2517 2517 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Previous")); 2230 2518 self.inner.unary(req, path, codec).await 2231 2519 } 2232 2520 pub async fn fast_forward_rewind( 2233 2521 &mut self, 2234 2522 request: impl tonic::IntoRequest<super::FastForwardRewindRequest>, 2235 2235 - ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status> 2236 2236 - { 2237 2237 - self.inner.ready().await.map_err(|e| { 2238 2238 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2239 2239 - })?; 2523 2523 + ) -> std::result::Result< 2524 2524 + tonic::Response<super::FastForwardRewindResponse>, 2525 2525 + tonic::Status, 2526 2526 + > { 2527 2527 + self.inner 2528 2528 + .ready() 2529 2529 + .await 2530 2530 + .map_err(|e| { 2531 2531 + tonic::Status::unknown( 2532 2532 + format!("Service was not ready: {}", e.into()), 2533 2533 + ) 2534 2534 + })?; 2240 2535 let codec = tonic::codec::ProstCodec::default(); 2241 2536 let path = http::uri::PathAndQuery::from_static( 2242 2537 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind", 2243 2538 ); 2244 2539 let mut req = request.into_request(); 2245 2245 - req.extensions_mut().insert(GrpcMethod::new( 2246 2246 - "rockbox.v1alpha1.PlaybackService", 2247 2247 - "FastForwardRewind", 2248 2248 - )); 2540 2540 + req.extensions_mut() 2541 2541 + .insert( 2542 2542 + GrpcMethod::new( 2543 2543 + "rockbox.v1alpha1.PlaybackService", 2544 2544 + "FastForwardRewind", 2545 2545 + ), 2546 2546 + ); 2249 2547 self.inner.unary(req, path, codec).await 2250 2548 } 2251 2549 pub async fn status( 2252 2550 &mut self, 2253 2551 request: impl tonic::IntoRequest<super::StatusRequest>, 2254 2552 ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> { 2255 2255 - self.inner.ready().await.map_err(|e| { 2256 2256 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2257 2257 - })?; 2553 2553 + self.inner 2554 2554 + .ready() 2555 2555 + .await 2556 2556 + .map_err(|e| { 2557 2557 + tonic::Status::unknown( 2558 2558 + format!("Service was not ready: {}", e.into()), 2559 2559 + ) 2560 2560 + })?; 2258 2561 let codec = tonic::codec::ProstCodec::default(); 2259 2259 - let path = 2260 2260 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Status"); 2562 2562 + let path = http::uri::PathAndQuery::from_static( 2563 2563 + "/rockbox.v1alpha1.PlaybackService/Status", 2564 2564 + ); 2261 2565 let mut req = request.into_request(); 2262 2262 - req.extensions_mut().insert(GrpcMethod::new( 2263 2263 - "rockbox.v1alpha1.PlaybackService", 2264 2264 - "Status", 2265 2265 - )); 2566 2566 + req.extensions_mut() 2567 2567 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Status")); 2266 2568 self.inner.unary(req, path, codec).await 2267 2569 } 2268 2570 pub async fn current_track( 2269 2571 &mut self, 2270 2572 request: impl tonic::IntoRequest<super::CurrentTrackRequest>, 2271 2271 - ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status> 2272 2272 - { 2273 2273 - self.inner.ready().await.map_err(|e| { 2274 2274 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2275 2275 - })?; 2573 2573 + ) -> std::result::Result< 2574 2574 + tonic::Response<super::CurrentTrackResponse>, 2575 2575 + tonic::Status, 2576 2576 + > { 2577 2577 + self.inner 2578 2578 + .ready() 2579 2579 + .await 2580 2580 + .map_err(|e| { 2581 2581 + tonic::Status::unknown( 2582 2582 + format!("Service was not ready: {}", e.into()), 2583 2583 + ) 2584 2584 + })?; 2276 2585 let codec = tonic::codec::ProstCodec::default(); 2277 2586 let path = http::uri::PathAndQuery::from_static( 2278 2587 "/rockbox.v1alpha1.PlaybackService/CurrentTrack", 2279 2588 ); 2280 2589 let mut req = request.into_request(); 2281 2281 - req.extensions_mut().insert(GrpcMethod::new( 2282 2282 - "rockbox.v1alpha1.PlaybackService", 2283 2283 - "CurrentTrack", 2284 2284 - )); 2590 2590 + req.extensions_mut() 2591 2591 + .insert( 2592 2592 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "CurrentTrack"), 2593 2593 + ); 2285 2594 self.inner.unary(req, path, codec).await 2286 2595 } 2287 2596 pub async fn next_track( 2288 2597 &mut self, 2289 2598 request: impl tonic::IntoRequest<super::NextTrackRequest>, 2290 2290 - ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status> { 2291 2291 - self.inner.ready().await.map_err(|e| { 2292 2292 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2293 2293 - })?; 2599 2599 + ) -> std::result::Result< 2600 2600 + tonic::Response<super::NextTrackResponse>, 2601 2601 + tonic::Status, 2602 2602 + > { 2603 2603 + self.inner 2604 2604 + .ready() 2605 2605 + .await 2606 2606 + .map_err(|e| { 2607 2607 + tonic::Status::unknown( 2608 2608 + format!("Service was not ready: {}", e.into()), 2609 2609 + ) 2610 2610 + })?; 2294 2611 let codec = tonic::codec::ProstCodec::default(); 2295 2295 - let path = 2296 2296 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/NextTrack"); 2612 2612 + let path = http::uri::PathAndQuery::from_static( 2613 2613 + "/rockbox.v1alpha1.PlaybackService/NextTrack", 2614 2614 + ); 2297 2615 let mut req = request.into_request(); 2298 2298 - req.extensions_mut().insert(GrpcMethod::new( 2299 2299 - "rockbox.v1alpha1.PlaybackService", 2300 2300 - "NextTrack", 2301 2301 - )); 2616 2616 + req.extensions_mut() 2617 2617 + .insert( 2618 2618 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "NextTrack"), 2619 2619 + ); 2302 2620 self.inner.unary(req, path, codec).await 2303 2621 } 2304 2622 pub async fn flush_and_reload_tracks( 2305 2623 &mut self, 2306 2624 request: impl tonic::IntoRequest<super::FlushAndReloadTracksRequest>, 2307 2307 - ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status> 2308 2308 - { 2309 2309 - self.inner.ready().await.map_err(|e| { 2310 2310 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2311 2311 - })?; 2625 2625 + ) -> std::result::Result< 2626 2626 + tonic::Response<super::FlushAndReloadTracksResponse>, 2627 2627 + tonic::Status, 2628 2628 + > { 2629 2629 + self.inner 2630 2630 + .ready() 2631 2631 + .await 2632 2632 + .map_err(|e| { 2633 2633 + tonic::Status::unknown( 2634 2634 + format!("Service was not ready: {}", e.into()), 2635 2635 + ) 2636 2636 + })?; 2312 2637 let codec = tonic::codec::ProstCodec::default(); 2313 2638 let path = http::uri::PathAndQuery::from_static( 2314 2639 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks", 2315 2640 ); 2316 2641 let mut req = request.into_request(); 2317 2317 - req.extensions_mut().insert(GrpcMethod::new( 2318 2318 - "rockbox.v1alpha1.PlaybackService", 2319 2319 - "FlushAndReloadTracks", 2320 2320 - )); 2642 2642 + req.extensions_mut() 2643 2643 + .insert( 2644 2644 + GrpcMethod::new( 2645 2645 + "rockbox.v1alpha1.PlaybackService", 2646 2646 + "FlushAndReloadTracks", 2647 2647 + ), 2648 2648 + ); 2321 2649 self.inner.unary(req, path, codec).await 2322 2650 } 2323 2651 pub async fn get_file_position( 2324 2652 &mut self, 2325 2653 request: impl tonic::IntoRequest<super::GetFilePositionRequest>, 2326 2326 - ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status> 2327 2327 - { 2328 2328 - self.inner.ready().await.map_err(|e| { 2329 2329 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2330 2330 - })?; 2654 2654 + ) -> std::result::Result< 2655 2655 + tonic::Response<super::GetFilePositionResponse>, 2656 2656 + tonic::Status, 2657 2657 + > { 2658 2658 + self.inner 2659 2659 + .ready() 2660 2660 + .await 2661 2661 + .map_err(|e| { 2662 2662 + tonic::Status::unknown( 2663 2663 + format!("Service was not ready: {}", e.into()), 2664 2664 + ) 2665 2665 + })?; 2331 2666 let codec = tonic::codec::ProstCodec::default(); 2332 2667 let path = http::uri::PathAndQuery::from_static( 2333 2668 "/rockbox.v1alpha1.PlaybackService/GetFilePosition", 2334 2669 ); 2335 2670 let mut req = request.into_request(); 2336 2336 - req.extensions_mut().insert(GrpcMethod::new( 2337 2337 - "rockbox.v1alpha1.PlaybackService", 2338 2338 - "GetFilePosition", 2339 2339 - )); 2671 2671 + req.extensions_mut() 2672 2672 + .insert( 2673 2673 + GrpcMethod::new( 2674 2674 + "rockbox.v1alpha1.PlaybackService", 2675 2675 + "GetFilePosition", 2676 2676 + ), 2677 2677 + ); 2340 2678 self.inner.unary(req, path, codec).await 2341 2679 } 2342 2680 pub async fn hard_stop( 2343 2681 &mut self, 2344 2682 request: impl tonic::IntoRequest<super::HardStopRequest>, 2345 2345 - ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status> { 2346 2346 - self.inner.ready().await.map_err(|e| { 2347 2347 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2348 2348 - })?; 2683 2683 + ) -> std::result::Result< 2684 2684 + tonic::Response<super::HardStopResponse>, 2685 2685 + tonic::Status, 2686 2686 + > { 2687 2687 + self.inner 2688 2688 + .ready() 2689 2689 + .await 2690 2690 + .map_err(|e| { 2691 2691 + tonic::Status::unknown( 2692 2692 + format!("Service was not ready: {}", e.into()), 2693 2693 + ) 2694 2694 + })?; 2349 2695 let codec = tonic::codec::ProstCodec::default(); 2350 2350 - let path = 2351 2351 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/HardStop"); 2696 2696 + let path = http::uri::PathAndQuery::from_static( 2697 2697 + "/rockbox.v1alpha1.PlaybackService/HardStop", 2698 2698 + ); 2352 2699 let mut req = request.into_request(); 2353 2353 - req.extensions_mut().insert(GrpcMethod::new( 2354 2354 - "rockbox.v1alpha1.PlaybackService", 2355 2355 - "HardStop", 2356 2356 - )); 2700 2700 + req.extensions_mut() 2701 2701 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "HardStop")); 2357 2702 self.inner.unary(req, path, codec).await 2358 2703 } 2359 2704 pub async fn play_album( 2360 2705 &mut self, 2361 2706 request: impl tonic::IntoRequest<super::PlayAlbumRequest>, 2362 2362 - ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status> { 2363 2363 - self.inner.ready().await.map_err(|e| { 2364 2364 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2365 2365 - })?; 2707 2707 + ) -> std::result::Result< 2708 2708 + tonic::Response<super::PlayAlbumResponse>, 2709 2709 + tonic::Status, 2710 2710 + > { 2711 2711 + self.inner 2712 2712 + .ready() 2713 2713 + .await 2714 2714 + .map_err(|e| { 2715 2715 + tonic::Status::unknown( 2716 2716 + format!("Service was not ready: {}", e.into()), 2717 2717 + ) 2718 2718 + })?; 2366 2719 let codec = tonic::codec::ProstCodec::default(); 2367 2367 - let path = 2368 2368 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayAlbum"); 2720 2720 + let path = http::uri::PathAndQuery::from_static( 2721 2721 + "/rockbox.v1alpha1.PlaybackService/PlayAlbum", 2722 2722 + ); 2369 2723 let mut req = request.into_request(); 2370 2370 - req.extensions_mut().insert(GrpcMethod::new( 2371 2371 - "rockbox.v1alpha1.PlaybackService", 2372 2372 - "PlayAlbum", 2373 2373 - )); 2724 2724 + req.extensions_mut() 2725 2725 + .insert( 2726 2726 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAlbum"), 2727 2727 + ); 2374 2728 self.inner.unary(req, path, codec).await 2375 2729 } 2376 2730 pub async fn play_artist_tracks( 2377 2731 &mut self, 2378 2732 request: impl tonic::IntoRequest<super::PlayArtistTracksRequest>, 2379 2379 - ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status> 2380 2380 - { 2381 2381 - self.inner.ready().await.map_err(|e| { 2382 2382 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2383 2383 - })?; 2733 2733 + ) -> std::result::Result< 2734 2734 + tonic::Response<super::PlayArtistTracksResponse>, 2735 2735 + tonic::Status, 2736 2736 + > { 2737 2737 + self.inner 2738 2738 + .ready() 2739 2739 + .await 2740 2740 + .map_err(|e| { 2741 2741 + tonic::Status::unknown( 2742 2742 + format!("Service was not ready: {}", e.into()), 2743 2743 + ) 2744 2744 + })?; 2384 2745 let codec = tonic::codec::ProstCodec::default(); 2385 2746 let path = http::uri::PathAndQuery::from_static( 2386 2747 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks", 2387 2748 ); 2388 2749 let mut req = request.into_request(); 2389 2389 - req.extensions_mut().insert(GrpcMethod::new( 2390 2390 - "rockbox.v1alpha1.PlaybackService", 2391 2391 - "PlayArtistTracks", 2392 2392 - )); 2750 2750 + req.extensions_mut() 2751 2751 + .insert( 2752 2752 + GrpcMethod::new( 2753 2753 + "rockbox.v1alpha1.PlaybackService", 2754 2754 + "PlayArtistTracks", 2755 2755 + ), 2756 2756 + ); 2393 2757 self.inner.unary(req, path, codec).await 2394 2758 } 2395 2759 pub async fn play_playlist( 2396 2760 &mut self, 2397 2761 request: impl tonic::IntoRequest<super::PlayPlaylistRequest>, 2398 2398 - ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status> 2399 2399 - { 2400 2400 - self.inner.ready().await.map_err(|e| { 2401 2401 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2402 2402 - })?; 2762 2762 + ) -> std::result::Result< 2763 2763 + tonic::Response<super::PlayPlaylistResponse>, 2764 2764 + tonic::Status, 2765 2765 + > { 2766 2766 + self.inner 2767 2767 + .ready() 2768 2768 + .await 2769 2769 + .map_err(|e| { 2770 2770 + tonic::Status::unknown( 2771 2771 + format!("Service was not ready: {}", e.into()), 2772 2772 + ) 2773 2773 + })?; 2403 2774 let codec = tonic::codec::ProstCodec::default(); 2404 2775 let path = http::uri::PathAndQuery::from_static( 2405 2776 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist", 2406 2777 ); 2407 2778 let mut req = request.into_request(); 2408 2408 - req.extensions_mut().insert(GrpcMethod::new( 2409 2409 - "rockbox.v1alpha1.PlaybackService", 2410 2410 - "PlayPlaylist", 2411 2411 - )); 2779 2779 + req.extensions_mut() 2780 2780 + .insert( 2781 2781 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayPlaylist"), 2782 2782 + ); 2412 2783 self.inner.unary(req, path, codec).await 2413 2784 } 2414 2785 pub async fn play_directory( 2415 2786 &mut self, 2416 2787 request: impl tonic::IntoRequest<super::PlayDirectoryRequest>, 2417 2417 - ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status> 2418 2418 - { 2419 2419 - self.inner.ready().await.map_err(|e| { 2420 2420 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2421 2421 - })?; 2788 2788 + ) -> std::result::Result< 2789 2789 + tonic::Response<super::PlayDirectoryResponse>, 2790 2790 + tonic::Status, 2791 2791 + > { 2792 2792 + self.inner 2793 2793 + .ready() 2794 2794 + .await 2795 2795 + .map_err(|e| { 2796 2796 + tonic::Status::unknown( 2797 2797 + format!("Service was not ready: {}", e.into()), 2798 2798 + ) 2799 2799 + })?; 2422 2800 let codec = tonic::codec::ProstCodec::default(); 2423 2801 let path = http::uri::PathAndQuery::from_static( 2424 2802 "/rockbox.v1alpha1.PlaybackService/PlayDirectory", 2425 2803 ); 2426 2804 let mut req = request.into_request(); 2427 2427 - req.extensions_mut().insert(GrpcMethod::new( 2428 2428 - "rockbox.v1alpha1.PlaybackService", 2429 2429 - "PlayDirectory", 2430 2430 - )); 2805 2805 + req.extensions_mut() 2806 2806 + .insert( 2807 2807 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayDirectory"), 2808 2808 + ); 2431 2809 self.inner.unary(req, path, codec).await 2432 2810 } 2433 2811 pub async fn play_track( 2434 2812 &mut self, 2435 2813 request: impl tonic::IntoRequest<super::PlayTrackRequest>, 2436 2436 - ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status> { 2437 2437 - self.inner.ready().await.map_err(|e| { 2438 2438 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2439 2439 - })?; 2814 2814 + ) -> std::result::Result< 2815 2815 + tonic::Response<super::PlayTrackResponse>, 2816 2816 + tonic::Status, 2817 2817 + > { 2818 2818 + self.inner 2819 2819 + .ready() 2820 2820 + .await 2821 2821 + .map_err(|e| { 2822 2822 + tonic::Status::unknown( 2823 2823 + format!("Service was not ready: {}", e.into()), 2824 2824 + ) 2825 2825 + })?; 2440 2826 let codec = tonic::codec::ProstCodec::default(); 2441 2441 - let path = 2442 2442 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayTrack"); 2827 2827 + let path = http::uri::PathAndQuery::from_static( 2828 2828 + "/rockbox.v1alpha1.PlaybackService/PlayTrack", 2829 2829 + ); 2443 2830 let mut req = request.into_request(); 2444 2444 - req.extensions_mut().insert(GrpcMethod::new( 2445 2445 - "rockbox.v1alpha1.PlaybackService", 2446 2446 - "PlayTrack", 2447 2447 - )); 2831 2831 + req.extensions_mut() 2832 2832 + .insert( 2833 2833 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayTrack"), 2834 2834 + ); 2448 2835 self.inner.unary(req, path, codec).await 2449 2836 } 2450 2837 pub async fn play_liked_tracks( 2451 2838 &mut self, 2452 2839 request: impl tonic::IntoRequest<super::PlayLikedTracksRequest>, 2453 2453 - ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status> 2454 2454 - { 2455 2455 - self.inner.ready().await.map_err(|e| { 2456 2456 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2457 2457 - })?; 2840 2840 + ) -> std::result::Result< 2841 2841 + tonic::Response<super::PlayLikedTracksResponse>, 2842 2842 + tonic::Status, 2843 2843 + > { 2844 2844 + self.inner 2845 2845 + .ready() 2846 2846 + .await 2847 2847 + .map_err(|e| { 2848 2848 + tonic::Status::unknown( 2849 2849 + format!("Service was not ready: {}", e.into()), 2850 2850 + ) 2851 2851 + })?; 2458 2852 let codec = tonic::codec::ProstCodec::default(); 2459 2853 let path = http::uri::PathAndQuery::from_static( 2460 2854 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks", 2461 2855 ); 2462 2856 let mut req = request.into_request(); 2463 2463 - req.extensions_mut().insert(GrpcMethod::new( 2464 2464 - "rockbox.v1alpha1.PlaybackService", 2465 2465 - "PlayLikedTracks", 2466 2466 - )); 2857 2857 + req.extensions_mut() 2858 2858 + .insert( 2859 2859 + GrpcMethod::new( 2860 2860 + "rockbox.v1alpha1.PlaybackService", 2861 2861 + "PlayLikedTracks", 2862 2862 + ), 2863 2863 + ); 2467 2864 self.inner.unary(req, path, codec).await 2468 2865 } 2469 2866 pub async fn play_all_tracks( 2470 2867 &mut self, 2471 2868 request: impl tonic::IntoRequest<super::PlayAllTracksRequest>, 2472 2472 - ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status> 2473 2473 - { 2474 2474 - self.inner.ready().await.map_err(|e| { 2475 2475 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2476 2476 - })?; 2869 2869 + ) -> std::result::Result< 2870 2870 + tonic::Response<super::PlayAllTracksResponse>, 2871 2871 + tonic::Status, 2872 2872 + > { 2873 2873 + self.inner 2874 2874 + .ready() 2875 2875 + .await 2876 2876 + .map_err(|e| { 2877 2877 + tonic::Status::unknown( 2878 2878 + format!("Service was not ready: {}", e.into()), 2879 2879 + ) 2880 2880 + })?; 2477 2881 let codec = tonic::codec::ProstCodec::default(); 2478 2882 let path = http::uri::PathAndQuery::from_static( 2479 2883 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks", 2480 2884 ); 2481 2885 let mut req = request.into_request(); 2482 2482 - req.extensions_mut().insert(GrpcMethod::new( 2483 2483 - "rockbox.v1alpha1.PlaybackService", 2484 2484 - "PlayAllTracks", 2485 2485 - )); 2886 2886 + req.extensions_mut() 2887 2887 + .insert( 2888 2888 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAllTracks"), 2889 2889 + ); 2486 2890 self.inner.unary(req, path, codec).await 2487 2891 } 2488 2892 pub async fn stream_current_track( ··· 2492 2896 tonic::Response<tonic::codec::Streaming<super::CurrentTrackResponse>>, 2493 2897 tonic::Status, 2494 2898 > { 2495 2495 - self.inner.ready().await.map_err(|e| { 2496 2496 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2497 2497 - })?; 2899 2899 + self.inner 2900 2900 + .ready() 2901 2901 + .await 2902 2902 + .map_err(|e| { 2903 2903 + tonic::Status::unknown( 2904 2904 + format!("Service was not ready: {}", e.into()), 2905 2905 + ) 2906 2906 + })?; 2498 2907 let codec = tonic::codec::ProstCodec::default(); 2499 2908 let path = http::uri::PathAndQuery::from_static( 2500 2909 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack", 2501 2910 ); 2502 2911 let mut req = request.into_request(); 2503 2503 - req.extensions_mut().insert(GrpcMethod::new( 2504 2504 - "rockbox.v1alpha1.PlaybackService", 2505 2505 - "StreamCurrentTrack", 2506 2506 - )); 2912 2912 + req.extensions_mut() 2913 2913 + .insert( 2914 2914 + GrpcMethod::new( 2915 2915 + "rockbox.v1alpha1.PlaybackService", 2916 2916 + "StreamCurrentTrack", 2917 2917 + ), 2918 2918 + ); 2507 2919 self.inner.server_streaming(req, path, codec).await 2508 2920 } 2509 2921 pub async fn stream_status( ··· 2513 2925 tonic::Response<tonic::codec::Streaming<super::StatusResponse>>, 2514 2926 tonic::Status, 2515 2927 > { 2516 2516 - self.inner.ready().await.map_err(|e| { 2517 2517 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2518 2518 - })?; 2928 2928 + self.inner 2929 2929 + .ready() 2930 2930 + .await 2931 2931 + .map_err(|e| { 2932 2932 + tonic::Status::unknown( 2933 2933 + format!("Service was not ready: {}", e.into()), 2934 2934 + ) 2935 2935 + })?; 2519 2936 let codec = tonic::codec::ProstCodec::default(); 2520 2937 let path = http::uri::PathAndQuery::from_static( 2521 2938 "/rockbox.v1alpha1.PlaybackService/StreamStatus", 2522 2939 ); 2523 2940 let mut req = request.into_request(); 2524 2524 - req.extensions_mut().insert(GrpcMethod::new( 2525 2525 - "rockbox.v1alpha1.PlaybackService", 2526 2526 - "StreamStatus", 2527 2527 - )); 2941 2941 + req.extensions_mut() 2942 2942 + .insert( 2943 2943 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamStatus"), 2944 2944 + ); 2528 2945 self.inner.server_streaming(req, path, codec).await 2529 2946 } 2530 2947 pub async fn stream_playlist( ··· 2534 2951 tonic::Response<tonic::codec::Streaming<super::PlaylistResponse>>, 2535 2952 tonic::Status, 2536 2953 > { 2537 2537 - self.inner.ready().await.map_err(|e| { 2538 2538 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2539 2539 - })?; 2954 2954 + self.inner 2955 2955 + .ready() 2956 2956 + .await 2957 2957 + .map_err(|e| { 2958 2958 + tonic::Status::unknown( 2959 2959 + format!("Service was not ready: {}", e.into()), 2960 2960 + ) 2961 2961 + })?; 2540 2962 let codec = tonic::codec::ProstCodec::default(); 2541 2963 let path = http::uri::PathAndQuery::from_static( 2542 2964 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist", 2543 2965 ); 2544 2966 let mut req = request.into_request(); 2545 2545 - req.extensions_mut().insert(GrpcMethod::new( 2546 2546 - "rockbox.v1alpha1.PlaybackService", 2547 2547 - "StreamPlaylist", 2548 2548 - )); 2967 2967 + req.extensions_mut() 2968 2968 + .insert( 2969 2969 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamPlaylist"), 2970 2970 + ); 2549 2971 self.inner.server_streaming(req, path, codec).await 2550 2972 } 2551 2973 } ··· 2557 2979 dead_code, 2558 2980 missing_docs, 2559 2981 clippy::wildcard_imports, 2560 2560 - clippy::let_unit_value 2982 2982 + clippy::let_unit_value, 2561 2983 )] 2562 2984 use tonic::codegen::*; 2563 2985 /// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer. ··· 2574 2996 async fn play_or_pause( 2575 2997 &self, 2576 2998 request: tonic::Request<super::PlayOrPauseRequest>, 2577 2577 - ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status>; 2999 2999 + ) -> std::result::Result< 3000 3000 + tonic::Response<super::PlayOrPauseResponse>, 3001 3001 + tonic::Status, 3002 3002 + >; 2578 3003 async fn resume( 2579 3004 &self, 2580 3005 request: tonic::Request<super::ResumeRequest>, ··· 2586 3011 async fn previous( 2587 3012 &self, 2588 3013 request: tonic::Request<super::PreviousRequest>, 2589 2589 - ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status>; 3014 3014 + ) -> std::result::Result< 3015 3015 + tonic::Response<super::PreviousResponse>, 3016 3016 + tonic::Status, 3017 3017 + >; 2590 3018 async fn fast_forward_rewind( 2591 3019 &self, 2592 3020 request: tonic::Request<super::FastForwardRewindRequest>, 2593 2593 - ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>; 3021 3021 + ) -> std::result::Result< 3022 3022 + tonic::Response<super::FastForwardRewindResponse>, 3023 3023 + tonic::Status, 3024 3024 + >; 2594 3025 async fn status( 2595 3026 &self, 2596 3027 request: tonic::Request<super::StatusRequest>, ··· 2598 3029 async fn current_track( 2599 3030 &self, 2600 3031 request: tonic::Request<super::CurrentTrackRequest>, 2601 2601 - ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status>; 3032 3032 + ) -> std::result::Result< 3033 3033 + tonic::Response<super::CurrentTrackResponse>, 3034 3034 + tonic::Status, 3035 3035 + >; 2602 3036 async fn next_track( 2603 3037 &self, 2604 3038 request: tonic::Request<super::NextTrackRequest>, 2605 2605 - ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status>; 3039 3039 + ) -> std::result::Result< 3040 3040 + tonic::Response<super::NextTrackResponse>, 3041 3041 + tonic::Status, 3042 3042 + >; 2606 3043 async fn flush_and_reload_tracks( 2607 3044 &self, 2608 3045 request: tonic::Request<super::FlushAndReloadTracksRequest>, 2609 2609 - ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status>; 3046 3046 + ) -> std::result::Result< 3047 3047 + tonic::Response<super::FlushAndReloadTracksResponse>, 3048 3048 + tonic::Status, 3049 3049 + >; 2610 3050 async fn get_file_position( 2611 3051 &self, 2612 3052 request: tonic::Request<super::GetFilePositionRequest>, 2613 2613 - ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status>; 3053 3053 + ) -> std::result::Result< 3054 3054 + tonic::Response<super::GetFilePositionResponse>, 3055 3055 + tonic::Status, 3056 3056 + >; 2614 3057 async fn hard_stop( 2615 3058 &self, 2616 3059 request: tonic::Request<super::HardStopRequest>, 2617 2617 - ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status>; 3060 3060 + ) -> std::result::Result< 3061 3061 + tonic::Response<super::HardStopResponse>, 3062 3062 + tonic::Status, 3063 3063 + >; 2618 3064 async fn play_album( 2619 3065 &self, 2620 3066 request: tonic::Request<super::PlayAlbumRequest>, 2621 2621 - ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status>; 3067 3067 + ) -> std::result::Result< 3068 3068 + tonic::Response<super::PlayAlbumResponse>, 3069 3069 + tonic::Status, 3070 3070 + >; 2622 3071 async fn play_artist_tracks( 2623 3072 &self, 2624 3073 request: tonic::Request<super::PlayArtistTracksRequest>, 2625 2625 - ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status>; 3074 3074 + ) -> std::result::Result< 3075 3075 + tonic::Response<super::PlayArtistTracksResponse>, 3076 3076 + tonic::Status, 3077 3077 + >; 2626 3078 async fn play_playlist( 2627 3079 &self, 2628 3080 request: tonic::Request<super::PlayPlaylistRequest>, 2629 2629 - ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status>; 3081 3081 + ) -> std::result::Result< 3082 3082 + tonic::Response<super::PlayPlaylistResponse>, 3083 3083 + tonic::Status, 3084 3084 + >; 2630 3085 async fn play_directory( 2631 3086 &self, 2632 3087 request: tonic::Request<super::PlayDirectoryRequest>, 2633 2633 - ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>; 3088 3088 + ) -> std::result::Result< 3089 3089 + tonic::Response<super::PlayDirectoryResponse>, 3090 3090 + tonic::Status, 3091 3091 + >; 2634 3092 async fn play_track( 2635 3093 &self, 2636 3094 request: tonic::Request<super::PlayTrackRequest>, 2637 2637 - ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status>; 3095 3095 + ) -> std::result::Result< 3096 3096 + tonic::Response<super::PlayTrackResponse>, 3097 3097 + tonic::Status, 3098 3098 + >; 2638 3099 async fn play_liked_tracks( 2639 3100 &self, 2640 3101 request: tonic::Request<super::PlayLikedTracksRequest>, 2641 2641 - ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status>; 3102 3102 + ) -> std::result::Result< 3103 3103 + tonic::Response<super::PlayLikedTracksResponse>, 3104 3104 + tonic::Status, 3105 3105 + >; 2642 3106 async fn play_all_tracks( 2643 3107 &self, 2644 3108 request: tonic::Request<super::PlayAllTracksRequest>, 2645 2645 - ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>; 3109 3109 + ) -> std::result::Result< 3110 3110 + tonic::Response<super::PlayAllTracksResponse>, 3111 3111 + tonic::Status, 3112 3112 + >; 2646 3113 /// Server streaming response type for the StreamCurrentTrack method. 2647 3114 type StreamCurrentTrackStream: tonic::codegen::tokio_stream::Stream< 2648 3115 Item = std::result::Result<super::CurrentTrackResponse, tonic::Status>, 2649 2649 - > + std::marker::Send 3116 3116 + > 3117 3117 + + std::marker::Send 2650 3118 + 'static; 2651 3119 async fn stream_current_track( 2652 3120 &self, 2653 3121 request: tonic::Request<super::StreamCurrentTrackRequest>, 2654 2654 - ) -> std::result::Result<tonic::Response<Self::StreamCurrentTrackStream>, tonic::Status>; 3122 3122 + ) -> std::result::Result< 3123 3123 + tonic::Response<Self::StreamCurrentTrackStream>, 3124 3124 + tonic::Status, 3125 3125 + >; 2655 3126 /// Server streaming response type for the StreamStatus method. 2656 3127 type StreamStatusStream: tonic::codegen::tokio_stream::Stream< 2657 3128 Item = std::result::Result<super::StatusResponse, tonic::Status>, 2658 2658 - > + std::marker::Send 3129 3129 + > 3130 3130 + + std::marker::Send 2659 3131 + 'static; 2660 3132 async fn stream_status( 2661 3133 &self, 2662 3134 request: tonic::Request<super::StreamStatusRequest>, 2663 2663 - ) -> std::result::Result<tonic::Response<Self::StreamStatusStream>, tonic::Status>; 3135 3135 + ) -> std::result::Result< 3136 3136 + tonic::Response<Self::StreamStatusStream>, 3137 3137 + tonic::Status, 3138 3138 + >; 2664 3139 /// Server streaming response type for the StreamPlaylist method. 2665 3140 type StreamPlaylistStream: tonic::codegen::tokio_stream::Stream< 2666 3141 Item = std::result::Result<super::PlaylistResponse, tonic::Status>, 2667 2667 - > + std::marker::Send 3142 3142 + > 3143 3143 + + std::marker::Send 2668 3144 + 'static; 2669 3145 async fn stream_playlist( 2670 3146 &self, 2671 3147 request: tonic::Request<super::StreamPlaylistRequest>, 2672 2672 - ) -> std::result::Result<tonic::Response<Self::StreamPlaylistStream>, tonic::Status>; 3148 3148 + ) -> std::result::Result< 3149 3149 + tonic::Response<Self::StreamPlaylistStream>, 3150 3150 + tonic::Status, 3151 3151 + >; 2673 3152 } 2674 3153 #[derive(Debug)] 2675 3154 pub struct PlaybackServiceServer<T> { ··· 2692 3171 max_encoding_message_size: None, 2693 3172 } 2694 3173 } 2695 2695 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 3174 3174 + pub fn with_interceptor<F>( 3175 3175 + inner: T, 3176 3176 + interceptor: F, 3177 3177 + ) -> InterceptedService<Self, F> 2696 3178 where 2697 3179 F: tonic::service::Interceptor, 2698 3180 { ··· 2747 3229 "/rockbox.v1alpha1.PlaybackService/Play" => { 2748 3230 #[allow(non_camel_case_types)] 2749 3231 struct PlaySvc<T: PlaybackService>(pub Arc<T>); 2750 2750 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 3232 3232 + impl< 3233 3233 + T: PlaybackService, 3234 3234 + > tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 2751 3235 type Response = super::PlayResponse; 2752 2752 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3236 3236 + type Future = BoxFuture< 3237 3237 + tonic::Response<Self::Response>, 3238 3238 + tonic::Status, 3239 3239 + >; 2753 3240 fn call( 2754 3241 &mut self, 2755 3242 request: tonic::Request<super::PlayRequest>, 2756 3243 ) -> Self::Future { 2757 3244 let inner = Arc::clone(&self.0); 2758 2758 - let fut = 2759 2759 - async move { <T as PlaybackService>::play(&inner, request).await }; 3245 3245 + let fut = async move { 3246 3246 + <T as PlaybackService>::play(&inner, request).await 3247 3247 + }; 2760 3248 Box::pin(fut) 2761 3249 } 2762 3250 } ··· 2785 3273 "/rockbox.v1alpha1.PlaybackService/Pause" => { 2786 3274 #[allow(non_camel_case_types)] 2787 3275 struct PauseSvc<T: PlaybackService>(pub Arc<T>); 2788 2788 - impl<T: PlaybackService> tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 3276 3276 + impl< 3277 3277 + T: PlaybackService, 3278 3278 + > tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 2789 3279 type Response = super::PauseResponse; 2790 2790 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3280 3280 + type Future = BoxFuture< 3281 3281 + tonic::Response<Self::Response>, 3282 3282 + tonic::Status, 3283 3283 + >; 2791 3284 fn call( 2792 3285 &mut self, 2793 3286 request: tonic::Request<super::PauseRequest>, 2794 3287 ) -> Self::Future { 2795 3288 let inner = Arc::clone(&self.0); 2796 2796 - let fut = 2797 2797 - async move { <T as PlaybackService>::pause(&inner, request).await }; 3289 3289 + let fut = async move { 3290 3290 + <T as PlaybackService>::pause(&inner, request).await 3291 3291 + }; 2798 3292 Box::pin(fut) 2799 3293 } 2800 3294 } ··· 2823 3317 "/rockbox.v1alpha1.PlaybackService/PlayOrPause" => { 2824 3318 #[allow(non_camel_case_types)] 2825 3319 struct PlayOrPauseSvc<T: PlaybackService>(pub Arc<T>); 2826 2826 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayOrPauseRequest> 2827 2827 - for PlayOrPauseSvc<T> 2828 2828 - { 3320 3320 + impl< 3321 3321 + T: PlaybackService, 3322 3322 + > tonic::server::UnaryService<super::PlayOrPauseRequest> 3323 3323 + for PlayOrPauseSvc<T> { 2829 3324 type Response = super::PlayOrPauseResponse; 2830 2830 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3325 3325 + type Future = BoxFuture< 3326 3326 + tonic::Response<Self::Response>, 3327 3327 + tonic::Status, 3328 3328 + >; 2831 3329 fn call( 2832 3330 &mut self, 2833 3331 request: tonic::Request<super::PlayOrPauseRequest>, ··· 2864 3362 "/rockbox.v1alpha1.PlaybackService/Resume" => { 2865 3363 #[allow(non_camel_case_types)] 2866 3364 struct ResumeSvc<T: PlaybackService>(pub Arc<T>); 2867 2867 - impl<T: PlaybackService> tonic::server::UnaryService<super::ResumeRequest> for ResumeSvc<T> { 3365 3365 + impl< 3366 3366 + T: PlaybackService, 3367 3367 + > tonic::server::UnaryService<super::ResumeRequest> 3368 3368 + for ResumeSvc<T> { 2868 3369 type Response = super::ResumeResponse; 2869 2869 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3370 3370 + type Future = BoxFuture< 3371 3371 + tonic::Response<Self::Response>, 3372 3372 + tonic::Status, 3373 3373 + >; 2870 3374 fn call( 2871 3375 &mut self, 2872 3376 request: tonic::Request<super::ResumeRequest>, ··· 2903 3407 "/rockbox.v1alpha1.PlaybackService/Next" => { 2904 3408 #[allow(non_camel_case_types)] 2905 3409 struct NextSvc<T: PlaybackService>(pub Arc<T>); 2906 2906 - impl<T: PlaybackService> tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 3410 3410 + impl< 3411 3411 + T: PlaybackService, 3412 3412 + > tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 2907 3413 type Response = super::NextResponse; 2908 2908 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3414 3414 + type Future = BoxFuture< 3415 3415 + tonic::Response<Self::Response>, 3416 3416 + tonic::Status, 3417 3417 + >; 2909 3418 fn call( 2910 3419 &mut self, 2911 3420 request: tonic::Request<super::NextRequest>, 2912 3421 ) -> Self::Future { 2913 3422 let inner = Arc::clone(&self.0); 2914 2914 - let fut = 2915 2915 - async move { <T as PlaybackService>::next(&inner, request).await }; 3423 3423 + let fut = async move { 3424 3424 + <T as PlaybackService>::next(&inner, request).await 3425 3425 + }; 2916 3426 Box::pin(fut) 2917 3427 } 2918 3428 } ··· 2941 3451 "/rockbox.v1alpha1.PlaybackService/Previous" => { 2942 3452 #[allow(non_camel_case_types)] 2943 3453 struct PreviousSvc<T: PlaybackService>(pub Arc<T>); 2944 2944 - impl<T: PlaybackService> tonic::server::UnaryService<super::PreviousRequest> for PreviousSvc<T> { 3454 3454 + impl< 3455 3455 + T: PlaybackService, 3456 3456 + > tonic::server::UnaryService<super::PreviousRequest> 3457 3457 + for PreviousSvc<T> { 2945 3458 type Response = super::PreviousResponse; 2946 2946 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3459 3459 + type Future = BoxFuture< 3460 3460 + tonic::Response<Self::Response>, 3461 3461 + tonic::Status, 3462 3462 + >; 2947 3463 fn call( 2948 3464 &mut self, 2949 3465 request: tonic::Request<super::PreviousRequest>, ··· 2980 3496 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind" => { 2981 3497 #[allow(non_camel_case_types)] 2982 3498 struct FastForwardRewindSvc<T: PlaybackService>(pub Arc<T>); 2983 2983 - impl<T: PlaybackService> 2984 2984 - tonic::server::UnaryService<super::FastForwardRewindRequest> 2985 2985 - for FastForwardRewindSvc<T> 2986 2986 - { 3499 3499 + impl< 3500 3500 + T: PlaybackService, 3501 3501 + > tonic::server::UnaryService<super::FastForwardRewindRequest> 3502 3502 + for FastForwardRewindSvc<T> { 2987 3503 type Response = super::FastForwardRewindResponse; 2988 2988 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3504 3504 + type Future = BoxFuture< 3505 3505 + tonic::Response<Self::Response>, 3506 3506 + tonic::Status, 3507 3507 + >; 2989 3508 fn call( 2990 3509 &mut self, 2991 3510 request: tonic::Request<super::FastForwardRewindRequest>, 2992 3511 ) -> Self::Future { 2993 3512 let inner = Arc::clone(&self.0); 2994 3513 let fut = async move { 2995 2995 - <T as PlaybackService>::fast_forward_rewind(&inner, request).await 3514 3514 + <T as PlaybackService>::fast_forward_rewind(&inner, request) 3515 3515 + .await 2996 3516 }; 2997 3517 Box::pin(fut) 2998 3518 } ··· 3022 3542 "/rockbox.v1alpha1.PlaybackService/Status" => { 3023 3543 #[allow(non_camel_case_types)] 3024 3544 struct StatusSvc<T: PlaybackService>(pub Arc<T>); 3025 3025 - impl<T: PlaybackService> tonic::server::UnaryService<super::StatusRequest> for StatusSvc<T> { 3545 3545 + impl< 3546 3546 + T: PlaybackService, 3547 3547 + > tonic::server::UnaryService<super::StatusRequest> 3548 3548 + for StatusSvc<T> { 3026 3549 type Response = super::StatusResponse; 3027 3027 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3550 3550 + type Future = BoxFuture< 3551 3551 + tonic::Response<Self::Response>, 3552 3552 + tonic::Status, 3553 3553 + >; 3028 3554 fn call( 3029 3555 &mut self, 3030 3556 request: tonic::Request<super::StatusRequest>, ··· 3061 3587 "/rockbox.v1alpha1.PlaybackService/CurrentTrack" => { 3062 3588 #[allow(non_camel_case_types)] 3063 3589 struct CurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 3064 3064 - impl<T: PlaybackService> tonic::server::UnaryService<super::CurrentTrackRequest> 3065 3065 - for CurrentTrackSvc<T> 3066 3066 - { 3590 3590 + impl< 3591 3591 + T: PlaybackService, 3592 3592 + > tonic::server::UnaryService<super::CurrentTrackRequest> 3593 3593 + for CurrentTrackSvc<T> { 3067 3594 type Response = super::CurrentTrackResponse; 3068 3068 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3595 3595 + type Future = BoxFuture< 3596 3596 + tonic::Response<Self::Response>, 3597 3597 + tonic::Status, 3598 3598 + >; 3069 3599 fn call( 3070 3600 &mut self, 3071 3601 request: tonic::Request<super::CurrentTrackRequest>, ··· 3102 3632 "/rockbox.v1alpha1.PlaybackService/NextTrack" => { 3103 3633 #[allow(non_camel_case_types)] 3104 3634 struct NextTrackSvc<T: PlaybackService>(pub Arc<T>); 3105 3105 - impl<T: PlaybackService> tonic::server::UnaryService<super::NextTrackRequest> for NextTrackSvc<T> { 3635 3635 + impl< 3636 3636 + T: PlaybackService, 3637 3637 + > tonic::server::UnaryService<super::NextTrackRequest> 3638 3638 + for NextTrackSvc<T> { 3106 3639 type Response = super::NextTrackResponse; 3107 3107 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3640 3640 + type Future = BoxFuture< 3641 3641 + tonic::Response<Self::Response>, 3642 3642 + tonic::Status, 3643 3643 + >; 3108 3644 fn call( 3109 3645 &mut self, 3110 3646 request: tonic::Request<super::NextTrackRequest>, ··· 3141 3677 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks" => { 3142 3678 #[allow(non_camel_case_types)] 3143 3679 struct FlushAndReloadTracksSvc<T: PlaybackService>(pub Arc<T>); 3144 3144 - impl<T: PlaybackService> 3145 3145 - tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3146 3146 - for FlushAndReloadTracksSvc<T> 3147 3147 - { 3680 3680 + impl< 3681 3681 + T: PlaybackService, 3682 3682 + > tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3683 3683 + for FlushAndReloadTracksSvc<T> { 3148 3684 type Response = super::FlushAndReloadTracksResponse; 3149 3149 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3685 3685 + type Future = BoxFuture< 3686 3686 + tonic::Response<Self::Response>, 3687 3687 + tonic::Status, 3688 3688 + >; 3150 3689 fn call( 3151 3690 &mut self, 3152 3691 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3153 3692 ) -> Self::Future { 3154 3693 let inner = Arc::clone(&self.0); 3155 3694 let fut = async move { 3156 3156 - <T as PlaybackService>::flush_and_reload_tracks(&inner, request) 3695 3695 + <T as PlaybackService>::flush_and_reload_tracks( 3696 3696 + &inner, 3697 3697 + request, 3698 3698 + ) 3157 3699 .await 3158 3700 }; 3159 3701 Box::pin(fut) ··· 3184 3726 "/rockbox.v1alpha1.PlaybackService/GetFilePosition" => { 3185 3727 #[allow(non_camel_case_types)] 3186 3728 struct GetFilePositionSvc<T: PlaybackService>(pub Arc<T>); 3187 3187 - impl<T: PlaybackService> 3188 3188 - tonic::server::UnaryService<super::GetFilePositionRequest> 3189 3189 - for GetFilePositionSvc<T> 3190 3190 - { 3729 3729 + impl< 3730 3730 + T: PlaybackService, 3731 3731 + > tonic::server::UnaryService<super::GetFilePositionRequest> 3732 3732 + for GetFilePositionSvc<T> { 3191 3733 type Response = super::GetFilePositionResponse; 3192 3192 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3734 3734 + type Future = BoxFuture< 3735 3735 + tonic::Response<Self::Response>, 3736 3736 + tonic::Status, 3737 3737 + >; 3193 3738 fn call( 3194 3739 &mut self, 3195 3740 request: tonic::Request<super::GetFilePositionRequest>, 3196 3741 ) -> Self::Future { 3197 3742 let inner = Arc::clone(&self.0); 3198 3743 let fut = async move { 3199 3199 - <T as PlaybackService>::get_file_position(&inner, request).await 3744 3744 + <T as PlaybackService>::get_file_position(&inner, request) 3745 3745 + .await 3200 3746 }; 3201 3747 Box::pin(fut) 3202 3748 } ··· 3226 3772 "/rockbox.v1alpha1.PlaybackService/HardStop" => { 3227 3773 #[allow(non_camel_case_types)] 3228 3774 struct HardStopSvc<T: PlaybackService>(pub Arc<T>); 3229 3229 - impl<T: PlaybackService> tonic::server::UnaryService<super::HardStopRequest> for HardStopSvc<T> { 3775 3775 + impl< 3776 3776 + T: PlaybackService, 3777 3777 + > tonic::server::UnaryService<super::HardStopRequest> 3778 3778 + for HardStopSvc<T> { 3230 3779 type Response = super::HardStopResponse; 3231 3231 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3780 3780 + type Future = BoxFuture< 3781 3781 + tonic::Response<Self::Response>, 3782 3782 + tonic::Status, 3783 3783 + >; 3232 3784 fn call( 3233 3785 &mut self, 3234 3786 request: tonic::Request<super::HardStopRequest>, ··· 3265 3817 "/rockbox.v1alpha1.PlaybackService/PlayAlbum" => { 3266 3818 #[allow(non_camel_case_types)] 3267 3819 struct PlayAlbumSvc<T: PlaybackService>(pub Arc<T>); 3268 3268 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayAlbumRequest> for PlayAlbumSvc<T> { 3820 3820 + impl< 3821 3821 + T: PlaybackService, 3822 3822 + > tonic::server::UnaryService<super::PlayAlbumRequest> 3823 3823 + for PlayAlbumSvc<T> { 3269 3824 type Response = super::PlayAlbumResponse; 3270 3270 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3825 3825 + type Future = BoxFuture< 3826 3826 + tonic::Response<Self::Response>, 3827 3827 + tonic::Status, 3828 3828 + >; 3271 3829 fn call( 3272 3830 &mut self, 3273 3831 request: tonic::Request<super::PlayAlbumRequest>, ··· 3304 3862 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks" => { 3305 3863 #[allow(non_camel_case_types)] 3306 3864 struct PlayArtistTracksSvc<T: PlaybackService>(pub Arc<T>); 3307 3307 - impl<T: PlaybackService> 3308 3308 - tonic::server::UnaryService<super::PlayArtistTracksRequest> 3309 3309 - for PlayArtistTracksSvc<T> 3310 3310 - { 3865 3865 + impl< 3866 3866 + T: PlaybackService, 3867 3867 + > tonic::server::UnaryService<super::PlayArtistTracksRequest> 3868 3868 + for PlayArtistTracksSvc<T> { 3311 3869 type Response = super::PlayArtistTracksResponse; 3312 3312 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3870 3870 + type Future = BoxFuture< 3871 3871 + tonic::Response<Self::Response>, 3872 3872 + tonic::Status, 3873 3873 + >; 3313 3874 fn call( 3314 3875 &mut self, 3315 3876 request: tonic::Request<super::PlayArtistTracksRequest>, 3316 3877 ) -> Self::Future { 3317 3878 let inner = Arc::clone(&self.0); 3318 3879 let fut = async move { 3319 3319 - <T as PlaybackService>::play_artist_tracks(&inner, request).await 3880 3880 + <T as PlaybackService>::play_artist_tracks(&inner, request) 3881 3881 + .await 3320 3882 }; 3321 3883 Box::pin(fut) 3322 3884 } ··· 3346 3908 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist" => { 3347 3909 #[allow(non_camel_case_types)] 3348 3910 struct PlayPlaylistSvc<T: PlaybackService>(pub Arc<T>); 3349 3349 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayPlaylistRequest> 3350 3350 - for PlayPlaylistSvc<T> 3351 3351 - { 3911 3911 + impl< 3912 3912 + T: PlaybackService, 3913 3913 + > tonic::server::UnaryService<super::PlayPlaylistRequest> 3914 3914 + for PlayPlaylistSvc<T> { 3352 3915 type Response = super::PlayPlaylistResponse; 3353 3353 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3916 3916 + type Future = BoxFuture< 3917 3917 + tonic::Response<Self::Response>, 3918 3918 + tonic::Status, 3919 3919 + >; 3354 3920 fn call( 3355 3921 &mut self, 3356 3922 request: tonic::Request<super::PlayPlaylistRequest>, ··· 3387 3953 "/rockbox.v1alpha1.PlaybackService/PlayDirectory" => { 3388 3954 #[allow(non_camel_case_types)] 3389 3955 struct PlayDirectorySvc<T: PlaybackService>(pub Arc<T>); 3390 3390 - impl<T: PlaybackService> 3391 3391 - tonic::server::UnaryService<super::PlayDirectoryRequest> 3392 3392 - for PlayDirectorySvc<T> 3393 3393 - { 3956 3956 + impl< 3957 3957 + T: PlaybackService, 3958 3958 + > tonic::server::UnaryService<super::PlayDirectoryRequest> 3959 3959 + for PlayDirectorySvc<T> { 3394 3960 type Response = super::PlayDirectoryResponse; 3395 3395 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3961 3961 + type Future = BoxFuture< 3962 3962 + tonic::Response<Self::Response>, 3963 3963 + tonic::Status, 3964 3964 + >; 3396 3965 fn call( 3397 3966 &mut self, 3398 3967 request: tonic::Request<super::PlayDirectoryRequest>, 3399 3968 ) -> Self::Future { 3400 3969 let inner = Arc::clone(&self.0); 3401 3970 let fut = async move { 3402 3402 - <T as PlaybackService>::play_directory(&inner, request).await 3971 3971 + <T as PlaybackService>::play_directory(&inner, request) 3972 3972 + .await 3403 3973 }; 3404 3974 Box::pin(fut) 3405 3975 } ··· 3429 3999 "/rockbox.v1alpha1.PlaybackService/PlayTrack" => { 3430 4000 #[allow(non_camel_case_types)] 3431 4001 struct PlayTrackSvc<T: PlaybackService>(pub Arc<T>); 3432 3432 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayTrackRequest> for PlayTrackSvc<T> { 4002 4002 + impl< 4003 4003 + T: PlaybackService, 4004 4004 + > tonic::server::UnaryService<super::PlayTrackRequest> 4005 4005 + for PlayTrackSvc<T> { 3433 4006 type Response = super::PlayTrackResponse; 3434 3434 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4007 4007 + type Future = BoxFuture< 4008 4008 + tonic::Response<Self::Response>, 4009 4009 + tonic::Status, 4010 4010 + >; 3435 4011 fn call( 3436 4012 &mut self, 3437 4013 request: tonic::Request<super::PlayTrackRequest>, ··· 3468 4044 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks" => { 3469 4045 #[allow(non_camel_case_types)] 3470 4046 struct PlayLikedTracksSvc<T: PlaybackService>(pub Arc<T>); 3471 3471 - impl<T: PlaybackService> 3472 3472 - tonic::server::UnaryService<super::PlayLikedTracksRequest> 3473 3473 - for PlayLikedTracksSvc<T> 3474 3474 - { 4047 4047 + impl< 4048 4048 + T: PlaybackService, 4049 4049 + > tonic::server::UnaryService<super::PlayLikedTracksRequest> 4050 4050 + for PlayLikedTracksSvc<T> { 3475 4051 type Response = super::PlayLikedTracksResponse; 3476 3476 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4052 4052 + type Future = BoxFuture< 4053 4053 + tonic::Response<Self::Response>, 4054 4054 + tonic::Status, 4055 4055 + >; 3477 4056 fn call( 3478 4057 &mut self, 3479 4058 request: tonic::Request<super::PlayLikedTracksRequest>, 3480 4059 ) -> Self::Future { 3481 4060 let inner = Arc::clone(&self.0); 3482 4061 let fut = async move { 3483 3483 - <T as PlaybackService>::play_liked_tracks(&inner, request).await 4062 4062 + <T as PlaybackService>::play_liked_tracks(&inner, request) 4063 4063 + .await 3484 4064 }; 3485 4065 Box::pin(fut) 3486 4066 } ··· 3510 4090 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks" => { 3511 4091 #[allow(non_camel_case_types)] 3512 4092 struct PlayAllTracksSvc<T: PlaybackService>(pub Arc<T>); 3513 3513 - impl<T: PlaybackService> 3514 3514 - tonic::server::UnaryService<super::PlayAllTracksRequest> 3515 3515 - for PlayAllTracksSvc<T> 3516 3516 - { 4093 4093 + impl< 4094 4094 + T: PlaybackService, 4095 4095 + > tonic::server::UnaryService<super::PlayAllTracksRequest> 4096 4096 + for PlayAllTracksSvc<T> { 3517 4097 type Response = super::PlayAllTracksResponse; 3518 3518 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4098 4098 + type Future = BoxFuture< 4099 4099 + tonic::Response<Self::Response>, 4100 4100 + tonic::Status, 4101 4101 + >; 3519 4102 fn call( 3520 4103 &mut self, 3521 4104 request: tonic::Request<super::PlayAllTracksRequest>, 3522 4105 ) -> Self::Future { 3523 4106 let inner = Arc::clone(&self.0); 3524 4107 let fut = async move { 3525 3525 - <T as PlaybackService>::play_all_tracks(&inner, request).await 4108 4108 + <T as PlaybackService>::play_all_tracks(&inner, request) 4109 4109 + .await 3526 4110 }; 3527 4111 Box::pin(fut) 3528 4112 } ··· 3552 4136 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack" => { 3553 4137 #[allow(non_camel_case_types)] 3554 4138 struct StreamCurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 3555 3555 - impl<T: PlaybackService> 3556 3556 - tonic::server::ServerStreamingService<super::StreamCurrentTrackRequest> 3557 3557 - for StreamCurrentTrackSvc<T> 3558 3558 - { 4139 4139 + impl< 4140 4140 + T: PlaybackService, 4141 4141 + > tonic::server::ServerStreamingService< 4142 4142 + super::StreamCurrentTrackRequest, 4143 4143 + > for StreamCurrentTrackSvc<T> { 3559 4144 type Response = super::CurrentTrackResponse; 3560 4145 type ResponseStream = T::StreamCurrentTrackStream; 3561 3561 - type Future = 3562 3562 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4146 4146 + type Future = BoxFuture< 4147 4147 + tonic::Response<Self::ResponseStream>, 4148 4148 + tonic::Status, 4149 4149 + >; 3563 4150 fn call( 3564 4151 &mut self, 3565 4152 request: tonic::Request<super::StreamCurrentTrackRequest>, 3566 4153 ) -> Self::Future { 3567 4154 let inner = Arc::clone(&self.0); 3568 4155 let fut = async move { 3569 3569 - <T as PlaybackService>::stream_current_track(&inner, request).await 4156 4156 + <T as PlaybackService>::stream_current_track( 4157 4157 + &inner, 4158 4158 + request, 4159 4159 + ) 4160 4160 + .await 3570 4161 }; 3571 4162 Box::pin(fut) 3572 4163 } ··· 3596 4187 "/rockbox.v1alpha1.PlaybackService/StreamStatus" => { 3597 4188 #[allow(non_camel_case_types)] 3598 4189 struct StreamStatusSvc<T: PlaybackService>(pub Arc<T>); 3599 3599 - impl<T: PlaybackService> 3600 3600 - tonic::server::ServerStreamingService<super::StreamStatusRequest> 3601 3601 - for StreamStatusSvc<T> 3602 3602 - { 4190 4190 + impl< 4191 4191 + T: PlaybackService, 4192 4192 + > tonic::server::ServerStreamingService<super::StreamStatusRequest> 4193 4193 + for StreamStatusSvc<T> { 3603 4194 type Response = super::StatusResponse; 3604 4195 type ResponseStream = T::StreamStatusStream; 3605 3605 - type Future = 3606 3606 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4196 4196 + type Future = BoxFuture< 4197 4197 + tonic::Response<Self::ResponseStream>, 4198 4198 + tonic::Status, 4199 4199 + >; 3607 4200 fn call( 3608 4201 &mut self, 3609 4202 request: tonic::Request<super::StreamStatusRequest>, ··· 3640 4233 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist" => { 3641 4234 #[allow(non_camel_case_types)] 3642 4235 struct StreamPlaylistSvc<T: PlaybackService>(pub Arc<T>); 3643 3643 - impl<T: PlaybackService> 3644 3644 - tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 3645 3645 - for StreamPlaylistSvc<T> 3646 3646 - { 4236 4236 + impl< 4237 4237 + T: PlaybackService, 4238 4238 + > tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 4239 4239 + for StreamPlaylistSvc<T> { 3647 4240 type Response = super::PlaylistResponse; 3648 4241 type ResponseStream = T::StreamPlaylistStream; 3649 3649 - type Future = 3650 3650 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4242 4242 + type Future = BoxFuture< 4243 4243 + tonic::Response<Self::ResponseStream>, 4244 4244 + tonic::Status, 4245 4245 + >; 3651 4246 fn call( 3652 4247 &mut self, 3653 4248 request: tonic::Request<super::StreamPlaylistRequest>, 3654 4249 ) -> Self::Future { 3655 4250 let inner = Arc::clone(&self.0); 3656 4251 let fut = async move { 3657 3657 - <T as PlaybackService>::stream_playlist(&inner, request).await 4252 4252 + <T as PlaybackService>::stream_playlist(&inner, request) 4253 4253 + .await 3658 4254 }; 3659 4255 Box::pin(fut) 3660 4256 } ··· 3681 4277 }; 3682 4278 Box::pin(fut) 3683 4279 } 3684 3684 - _ => Box::pin(async move { 3685 3685 - let mut response = http::Response::new(empty_body()); 3686 3686 - let headers = response.headers_mut(); 3687 3687 - headers.insert( 3688 3688 - tonic::Status::GRPC_STATUS, 3689 3689 - (tonic::Code::Unimplemented as i32).into(), 3690 3690 - ); 3691 3691 - headers.insert( 3692 3692 - http::header::CONTENT_TYPE, 3693 3693 - tonic::metadata::GRPC_CONTENT_TYPE, 3694 3694 - ); 3695 3695 - Ok(response) 3696 3696 - }), 4280 4280 + _ => { 4281 4281 + Box::pin(async move { 4282 4282 + let mut response = http::Response::new(empty_body()); 4283 4283 + let headers = response.headers_mut(); 4284 4284 + headers 4285 4285 + .insert( 4286 4286 + tonic::Status::GRPC_STATUS, 4287 4287 + (tonic::Code::Unimplemented as i32).into(), 4288 4288 + ); 4289 4289 + headers 4290 4290 + .insert( 4291 4291 + http::header::CONTENT_TYPE, 4292 4292 + tonic::metadata::GRPC_CONTENT_TYPE, 4293 4293 + ); 4294 4294 + Ok(response) 4295 4295 + }) 4296 4296 + } 3697 4297 } 3698 4298 } 3699 4299 } ··· 3900 4500 dead_code, 3901 4501 missing_docs, 3902 4502 clippy::wildcard_imports, 3903 3903 - clippy::let_unit_value 4503 4503 + clippy::let_unit_value, 3904 4504 )] 3905 3905 - use tonic::codegen::http::Uri; 3906 4505 use tonic::codegen::*; 4506 4506 + use tonic::codegen::http::Uri; 3907 4507 #[derive(Debug, Clone)] 3908 4508 pub struct PlaylistServiceClient<T> { 3909 4509 inner: tonic::client::Grpc<T>, ··· 3947 4547 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 3948 4548 >, 3949 4549 >, 3950 3950 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 3951 3951 - Into<StdError> + std::marker::Send + std::marker::Sync, 4550 4550 + <T as tonic::codegen::Service< 4551 4551 + http::Request<tonic::body::BoxBody>, 4552 4552 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 3952 4553 { 3953 4554 PlaylistServiceClient::new(InterceptedService::new(inner, interceptor)) 3954 4555 } ··· 3986 4587 pub async fn get_current( 3987 4588 &mut self, 3988 4589 request: impl tonic::IntoRequest<super::GetCurrentRequest>, 3989 3989 - ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status> 3990 3990 - { 3991 3991 - self.inner.ready().await.map_err(|e| { 3992 3992 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3993 3993 - })?; 4590 4590 + ) -> std::result::Result< 4591 4591 + tonic::Response<super::GetCurrentResponse>, 4592 4592 + tonic::Status, 4593 4593 + > { 4594 4594 + self.inner 4595 4595 + .ready() 4596 4596 + .await 4597 4597 + .map_err(|e| { 4598 4598 + tonic::Status::unknown( 4599 4599 + format!("Service was not ready: {}", e.into()), 4600 4600 + ) 4601 4601 + })?; 3994 4602 let codec = tonic::codec::ProstCodec::default(); 3995 4603 let path = http::uri::PathAndQuery::from_static( 3996 4604 "/rockbox.v1alpha1.PlaylistService/GetCurrent", 3997 4605 ); 3998 4606 let mut req = request.into_request(); 3999 3999 - req.extensions_mut().insert(GrpcMethod::new( 4000 4000 - "rockbox.v1alpha1.PlaylistService", 4001 4001 - "GetCurrent", 4002 4002 - )); 4607 4607 + req.extensions_mut() 4608 4608 + .insert( 4609 4609 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetCurrent"), 4610 4610 + ); 4003 4611 self.inner.unary(req, path, codec).await 4004 4612 } 4005 4613 pub async fn get_resume_info( 4006 4614 &mut self, 4007 4615 request: impl tonic::IntoRequest<super::GetResumeInfoRequest>, 4008 4008 - ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status> 4009 4009 - { 4010 4010 - self.inner.ready().await.map_err(|e| { 4011 4011 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4012 4012 - })?; 4616 4616 + ) -> std::result::Result< 4617 4617 + tonic::Response<super::GetResumeInfoResponse>, 4618 4618 + tonic::Status, 4619 4619 + > { 4620 4620 + self.inner 4621 4621 + .ready() 4622 4622 + .await 4623 4623 + .map_err(|e| { 4624 4624 + tonic::Status::unknown( 4625 4625 + format!("Service was not ready: {}", e.into()), 4626 4626 + ) 4627 4627 + })?; 4013 4628 let codec = tonic::codec::ProstCodec::default(); 4014 4629 let path = http::uri::PathAndQuery::from_static( 4015 4630 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo", 4016 4631 ); 4017 4632 let mut req = request.into_request(); 4018 4018 - req.extensions_mut().insert(GrpcMethod::new( 4019 4019 - "rockbox.v1alpha1.PlaylistService", 4020 4020 - "GetResumeInfo", 4021 4021 - )); 4633 4633 + req.extensions_mut() 4634 4634 + .insert( 4635 4635 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetResumeInfo"), 4636 4636 + ); 4022 4637 self.inner.unary(req, path, codec).await 4023 4638 } 4024 4639 pub async fn get_track_info( 4025 4640 &mut self, 4026 4641 request: impl tonic::IntoRequest<super::GetTrackInfoRequest>, 4027 4027 - ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status> 4028 4028 - { 4029 4029 - self.inner.ready().await.map_err(|e| { 4030 4030 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4031 4031 - })?; 4642 4642 + ) -> std::result::Result< 4643 4643 + tonic::Response<super::GetTrackInfoResponse>, 4644 4644 + tonic::Status, 4645 4645 + > { 4646 4646 + self.inner 4647 4647 + .ready() 4648 4648 + .await 4649 4649 + .map_err(|e| { 4650 4650 + tonic::Status::unknown( 4651 4651 + format!("Service was not ready: {}", e.into()), 4652 4652 + ) 4653 4653 + })?; 4032 4654 let codec = tonic::codec::ProstCodec::default(); 4033 4655 let path = http::uri::PathAndQuery::from_static( 4034 4656 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo", 4035 4657 ); 4036 4658 let mut req = request.into_request(); 4037 4037 - req.extensions_mut().insert(GrpcMethod::new( 4038 4038 - "rockbox.v1alpha1.PlaylistService", 4039 4039 - "GetTrackInfo", 4040 4040 - )); 4659 4659 + req.extensions_mut() 4660 4660 + .insert( 4661 4661 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetTrackInfo"), 4662 4662 + ); 4041 4663 self.inner.unary(req, path, codec).await 4042 4664 } 4043 4665 pub async fn get_first_index( 4044 4666 &mut self, 4045 4667 request: impl tonic::IntoRequest<super::GetFirstIndexRequest>, 4046 4046 - ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status> 4047 4047 - { 4048 4048 - self.inner.ready().await.map_err(|e| { 4049 4049 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4050 4050 - })?; 4668 4668 + ) -> std::result::Result< 4669 4669 + tonic::Response<super::GetFirstIndexResponse>, 4670 4670 + tonic::Status, 4671 4671 + > { 4672 4672 + self.inner 4673 4673 + .ready() 4674 4674 + .await 4675 4675 + .map_err(|e| { 4676 4676 + tonic::Status::unknown( 4677 4677 + format!("Service was not ready: {}", e.into()), 4678 4678 + ) 4679 4679 + })?; 4051 4680 let codec = tonic::codec::ProstCodec::default(); 4052 4681 let path = http::uri::PathAndQuery::from_static( 4053 4682 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex", 4054 4683 ); 4055 4684 let mut req = request.into_request(); 4056 4056 - req.extensions_mut().insert(GrpcMethod::new( 4057 4057 - "rockbox.v1alpha1.PlaylistService", 4058 4058 - "GetFirstIndex", 4059 4059 - )); 4685 4685 + req.extensions_mut() 4686 4686 + .insert( 4687 4687 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetFirstIndex"), 4688 4688 + ); 4060 4689 self.inner.unary(req, path, codec).await 4061 4690 } 4062 4691 pub async fn get_display_index( 4063 4692 &mut self, 4064 4693 request: impl tonic::IntoRequest<super::GetDisplayIndexRequest>, 4065 4065 - ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status> 4066 4066 - { 4067 4067 - self.inner.ready().await.map_err(|e| { 4068 4068 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4069 4069 - })?; 4694 4694 + ) -> std::result::Result< 4695 4695 + tonic::Response<super::GetDisplayIndexResponse>, 4696 4696 + tonic::Status, 4697 4697 + > { 4698 4698 + self.inner 4699 4699 + .ready() 4700 4700 + .await 4701 4701 + .map_err(|e| { 4702 4702 + tonic::Status::unknown( 4703 4703 + format!("Service was not ready: {}", e.into()), 4704 4704 + ) 4705 4705 + })?; 4070 4706 let codec = tonic::codec::ProstCodec::default(); 4071 4707 let path = http::uri::PathAndQuery::from_static( 4072 4708 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex", 4073 4709 ); 4074 4710 let mut req = request.into_request(); 4075 4075 - req.extensions_mut().insert(GrpcMethod::new( 4076 4076 - "rockbox.v1alpha1.PlaylistService", 4077 4077 - "GetDisplayIndex", 4078 4078 - )); 4711 4711 + req.extensions_mut() 4712 4712 + .insert( 4713 4713 + GrpcMethod::new( 4714 4714 + "rockbox.v1alpha1.PlaylistService", 4715 4715 + "GetDisplayIndex", 4716 4716 + ), 4717 4717 + ); 4079 4718 self.inner.unary(req, path, codec).await 4080 4719 } 4081 4720 pub async fn amount( 4082 4721 &mut self, 4083 4722 request: impl tonic::IntoRequest<super::AmountRequest>, 4084 4723 ) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status> { 4085 4085 - self.inner.ready().await.map_err(|e| { 4086 4086 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4087 4087 - })?; 4724 4724 + self.inner 4725 4725 + .ready() 4726 4726 + .await 4727 4727 + .map_err(|e| { 4728 4728 + tonic::Status::unknown( 4729 4729 + format!("Service was not ready: {}", e.into()), 4730 4730 + ) 4731 4731 + })?; 4088 4732 let codec = tonic::codec::ProstCodec::default(); 4089 4089 - let path = 4090 4090 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Amount"); 4733 4733 + let path = http::uri::PathAndQuery::from_static( 4734 4734 + "/rockbox.v1alpha1.PlaylistService/Amount", 4735 4735 + ); 4091 4736 let mut req = request.into_request(); 4092 4092 - req.extensions_mut().insert(GrpcMethod::new( 4093 4093 - "rockbox.v1alpha1.PlaylistService", 4094 4094 - "Amount", 4095 4095 - )); 4737 4737 + req.extensions_mut() 4738 4738 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Amount")); 4096 4739 self.inner.unary(req, path, codec).await 4097 4740 } 4098 4741 pub async fn playlist_resume( 4099 4742 &mut self, 4100 4743 request: impl tonic::IntoRequest<super::PlaylistResumeRequest>, 4101 4101 - ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status> 4102 4102 - { 4103 4103 - self.inner.ready().await.map_err(|e| { 4104 4104 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4105 4105 - })?; 4744 4744 + ) -> std::result::Result< 4745 4745 + tonic::Response<super::PlaylistResumeResponse>, 4746 4746 + tonic::Status, 4747 4747 + > { 4748 4748 + self.inner 4749 4749 + .ready() 4750 4750 + .await 4751 4751 + .map_err(|e| { 4752 4752 + tonic::Status::unknown( 4753 4753 + format!("Service was not ready: {}", e.into()), 4754 4754 + ) 4755 4755 + })?; 4106 4756 let codec = tonic::codec::ProstCodec::default(); 4107 4757 let path = http::uri::PathAndQuery::from_static( 4108 4758 "/rockbox.v1alpha1.PlaylistService/PlaylistResume", 4109 4759 ); 4110 4760 let mut req = request.into_request(); 4111 4111 - req.extensions_mut().insert(GrpcMethod::new( 4112 4112 - "rockbox.v1alpha1.PlaylistService", 4113 4113 - "PlaylistResume", 4114 4114 - )); 4761 4761 + req.extensions_mut() 4762 4762 + .insert( 4763 4763 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "PlaylistResume"), 4764 4764 + ); 4115 4765 self.inner.unary(req, path, codec).await 4116 4766 } 4117 4767 pub async fn resume_track( 4118 4768 &mut self, 4119 4769 request: impl tonic::IntoRequest<super::ResumeTrackRequest>, 4120 4120 - ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status> 4121 4121 - { 4122 4122 - self.inner.ready().await.map_err(|e| { 4123 4123 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4124 4124 - })?; 4770 4770 + ) -> std::result::Result< 4771 4771 + tonic::Response<super::ResumeTrackResponse>, 4772 4772 + tonic::Status, 4773 4773 + > { 4774 4774 + self.inner 4775 4775 + .ready() 4776 4776 + .await 4777 4777 + .map_err(|e| { 4778 4778 + tonic::Status::unknown( 4779 4779 + format!("Service was not ready: {}", e.into()), 4780 4780 + ) 4781 4781 + })?; 4125 4782 let codec = tonic::codec::ProstCodec::default(); 4126 4783 let path = http::uri::PathAndQuery::from_static( 4127 4784 "/rockbox.v1alpha1.PlaylistService/ResumeTrack", 4128 4785 ); 4129 4786 let mut req = request.into_request(); 4130 4130 - req.extensions_mut().insert(GrpcMethod::new( 4131 4131 - "rockbox.v1alpha1.PlaylistService", 4132 4132 - "ResumeTrack", 4133 4133 - )); 4787 4787 + req.extensions_mut() 4788 4788 + .insert( 4789 4789 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "ResumeTrack"), 4790 4790 + ); 4134 4791 self.inner.unary(req, path, codec).await 4135 4792 } 4136 4793 pub async fn set_modified( 4137 4794 &mut self, 4138 4795 request: impl tonic::IntoRequest<super::SetModifiedRequest>, 4139 4139 - ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status> 4140 4140 - { 4141 4141 - self.inner.ready().await.map_err(|e| { 4142 4142 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4143 4143 - })?; 4796 4796 + ) -> std::result::Result< 4797 4797 + tonic::Response<super::SetModifiedResponse>, 4798 4798 + tonic::Status, 4799 4799 + > { 4800 4800 + self.inner 4801 4801 + .ready() 4802 4802 + .await 4803 4803 + .map_err(|e| { 4804 4804 + tonic::Status::unknown( 4805 4805 + format!("Service was not ready: {}", e.into()), 4806 4806 + ) 4807 4807 + })?; 4144 4808 let codec = tonic::codec::ProstCodec::default(); 4145 4809 let path = http::uri::PathAndQuery::from_static( 4146 4810 "/rockbox.v1alpha1.PlaylistService/SetModified", 4147 4811 ); 4148 4812 let mut req = request.into_request(); 4149 4149 - req.extensions_mut().insert(GrpcMethod::new( 4150 4150 - "rockbox.v1alpha1.PlaylistService", 4151 4151 - "SetModified", 4152 4152 - )); 4813 4813 + req.extensions_mut() 4814 4814 + .insert( 4815 4815 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "SetModified"), 4816 4816 + ); 4153 4817 self.inner.unary(req, path, codec).await 4154 4818 } 4155 4819 pub async fn start( 4156 4820 &mut self, 4157 4821 request: impl tonic::IntoRequest<super::StartRequest>, 4158 4822 ) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status> { 4159 4159 - self.inner.ready().await.map_err(|e| { 4160 4160 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4161 4161 - })?; 4823 4823 + self.inner 4824 4824 + .ready() 4825 4825 + .await 4826 4826 + .map_err(|e| { 4827 4827 + tonic::Status::unknown( 4828 4828 + format!("Service was not ready: {}", e.into()), 4829 4829 + ) 4830 4830 + })?; 4162 4831 let codec = tonic::codec::ProstCodec::default(); 4163 4163 - let path = 4164 4164 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Start"); 4832 4832 + let path = http::uri::PathAndQuery::from_static( 4833 4833 + "/rockbox.v1alpha1.PlaylistService/Start", 4834 4834 + ); 4165 4835 let mut req = request.into_request(); 4166 4836 req.extensions_mut() 4167 4837 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Start")); ··· 4171 4841 &mut self, 4172 4842 request: impl tonic::IntoRequest<super::SyncRequest>, 4173 4843 ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> { 4174 4174 - self.inner.ready().await.map_err(|e| { 4175 4175 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4176 4176 - })?; 4844 4844 + self.inner 4845 4845 + .ready() 4846 4846 + .await 4847 4847 + .map_err(|e| { 4848 4848 + tonic::Status::unknown( 4849 4849 + format!("Service was not ready: {}", e.into()), 4850 4850 + ) 4851 4851 + })?; 4177 4852 let codec = tonic::codec::ProstCodec::default(); 4178 4178 - let path = 4179 4179 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Sync"); 4853 4853 + let path = http::uri::PathAndQuery::from_static( 4854 4854 + "/rockbox.v1alpha1.PlaylistService/Sync", 4855 4855 + ); 4180 4856 let mut req = request.into_request(); 4181 4857 req.extensions_mut() 4182 4858 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Sync")); ··· 4185 4861 pub async fn remove_all_tracks( 4186 4862 &mut self, 4187 4863 request: impl tonic::IntoRequest<super::RemoveAllTracksRequest>, 4188 4188 - ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status> 4189 4189 - { 4190 4190 - self.inner.ready().await.map_err(|e| { 4191 4191 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4192 4192 - })?; 4864 4864 + ) -> std::result::Result< 4865 4865 + tonic::Response<super::RemoveAllTracksResponse>, 4866 4866 + tonic::Status, 4867 4867 + > { 4868 4868 + self.inner 4869 4869 + .ready() 4870 4870 + .await 4871 4871 + .map_err(|e| { 4872 4872 + tonic::Status::unknown( 4873 4873 + format!("Service was not ready: {}", e.into()), 4874 4874 + ) 4875 4875 + })?; 4193 4876 let codec = tonic::codec::ProstCodec::default(); 4194 4877 let path = http::uri::PathAndQuery::from_static( 4195 4878 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks", 4196 4879 ); 4197 4880 let mut req = request.into_request(); 4198 4198 - req.extensions_mut().insert(GrpcMethod::new( 4199 4199 - "rockbox.v1alpha1.PlaylistService", 4200 4200 - "RemoveAllTracks", 4201 4201 - )); 4881 4881 + req.extensions_mut() 4882 4882 + .insert( 4883 4883 + GrpcMethod::new( 4884 4884 + "rockbox.v1alpha1.PlaylistService", 4885 4885 + "RemoveAllTracks", 4886 4886 + ), 4887 4887 + ); 4202 4888 self.inner.unary(req, path, codec).await 4203 4889 } 4204 4890 pub async fn remove_tracks( 4205 4891 &mut self, 4206 4892 request: impl tonic::IntoRequest<super::RemoveTracksRequest>, 4207 4207 - ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status> 4208 4208 - { 4209 4209 - self.inner.ready().await.map_err(|e| { 4210 4210 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4211 4211 - })?; 4893 4893 + ) -> std::result::Result< 4894 4894 + tonic::Response<super::RemoveTracksResponse>, 4895 4895 + tonic::Status, 4896 4896 + > { 4897 4897 + self.inner 4898 4898 + .ready() 4899 4899 + .await 4900 4900 + .map_err(|e| { 4901 4901 + tonic::Status::unknown( 4902 4902 + format!("Service was not ready: {}", e.into()), 4903 4903 + ) 4904 4904 + })?; 4212 4905 let codec = tonic::codec::ProstCodec::default(); 4213 4906 let path = http::uri::PathAndQuery::from_static( 4214 4907 "/rockbox.v1alpha1.PlaylistService/RemoveTracks", 4215 4908 ); 4216 4909 let mut req = request.into_request(); 4217 4217 - req.extensions_mut().insert(GrpcMethod::new( 4218 4218 - "rockbox.v1alpha1.PlaylistService", 4219 4219 - "RemoveTracks", 4220 4220 - )); 4910 4910 + req.extensions_mut() 4911 4911 + .insert( 4912 4912 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "RemoveTracks"), 4913 4913 + ); 4221 4914 self.inner.unary(req, path, codec).await 4222 4915 } 4223 4916 pub async fn create_playlist( 4224 4917 &mut self, 4225 4918 request: impl tonic::IntoRequest<super::CreatePlaylistRequest>, 4226 4226 - ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status> 4227 4227 - { 4228 4228 - self.inner.ready().await.map_err(|e| { 4229 4229 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4230 4230 - })?; 4919 4919 + ) -> std::result::Result< 4920 4920 + tonic::Response<super::CreatePlaylistResponse>, 4921 4921 + tonic::Status, 4922 4922 + > { 4923 4923 + self.inner 4924 4924 + .ready() 4925 4925 + .await 4926 4926 + .map_err(|e| { 4927 4927 + tonic::Status::unknown( 4928 4928 + format!("Service was not ready: {}", e.into()), 4929 4929 + ) 4930 4930 + })?; 4231 4931 let codec = tonic::codec::ProstCodec::default(); 4232 4932 let path = http::uri::PathAndQuery::from_static( 4233 4933 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist", 4234 4934 ); 4235 4935 let mut req = request.into_request(); 4236 4236 - req.extensions_mut().insert(GrpcMethod::new( 4237 4237 - "rockbox.v1alpha1.PlaylistService", 4238 4238 - "CreatePlaylist", 4239 4239 - )); 4936 4936 + req.extensions_mut() 4937 4937 + .insert( 4938 4938 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "CreatePlaylist"), 4939 4939 + ); 4240 4940 self.inner.unary(req, path, codec).await 4241 4941 } 4242 4942 pub async fn insert_tracks( 4243 4943 &mut self, 4244 4944 request: impl tonic::IntoRequest<super::InsertTracksRequest>, 4245 4245 - ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status> 4246 4246 - { 4247 4247 - self.inner.ready().await.map_err(|e| { 4248 4248 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4249 4249 - })?; 4945 4945 + ) -> std::result::Result< 4946 4946 + tonic::Response<super::InsertTracksResponse>, 4947 4947 + tonic::Status, 4948 4948 + > { 4949 4949 + self.inner 4950 4950 + .ready() 4951 4951 + .await 4952 4952 + .map_err(|e| { 4953 4953 + tonic::Status::unknown( 4954 4954 + format!("Service was not ready: {}", e.into()), 4955 4955 + ) 4956 4956 + })?; 4250 4957 let codec = tonic::codec::ProstCodec::default(); 4251 4958 let path = http::uri::PathAndQuery::from_static( 4252 4959 "/rockbox.v1alpha1.PlaylistService/InsertTracks", 4253 4960 ); 4254 4961 let mut req = request.into_request(); 4255 4255 - req.extensions_mut().insert(GrpcMethod::new( 4256 4256 - "rockbox.v1alpha1.PlaylistService", 4257 4257 - "InsertTracks", 4258 4258 - )); 4962 4962 + req.extensions_mut() 4963 4963 + .insert( 4964 4964 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertTracks"), 4965 4965 + ); 4259 4966 self.inner.unary(req, path, codec).await 4260 4967 } 4261 4968 pub async fn insert_directory( 4262 4969 &mut self, 4263 4970 request: impl tonic::IntoRequest<super::InsertDirectoryRequest>, 4264 4264 - ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status> 4265 4265 - { 4266 4266 - self.inner.ready().await.map_err(|e| { 4267 4267 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4268 4268 - })?; 4971 4971 + ) -> std::result::Result< 4972 4972 + tonic::Response<super::InsertDirectoryResponse>, 4973 4973 + tonic::Status, 4974 4974 + > { 4975 4975 + self.inner 4976 4976 + .ready() 4977 4977 + .await 4978 4978 + .map_err(|e| { 4979 4979 + tonic::Status::unknown( 4980 4980 + format!("Service was not ready: {}", e.into()), 4981 4981 + ) 4982 4982 + })?; 4269 4983 let codec = tonic::codec::ProstCodec::default(); 4270 4984 let path = http::uri::PathAndQuery::from_static( 4271 4985 "/rockbox.v1alpha1.PlaylistService/InsertDirectory", 4272 4986 ); 4273 4987 let mut req = request.into_request(); 4274 4274 - req.extensions_mut().insert(GrpcMethod::new( 4275 4275 - "rockbox.v1alpha1.PlaylistService", 4276 4276 - "InsertDirectory", 4277 4277 - )); 4988 4988 + req.extensions_mut() 4989 4989 + .insert( 4990 4990 + GrpcMethod::new( 4991 4991 + "rockbox.v1alpha1.PlaylistService", 4992 4992 + "InsertDirectory", 4993 4993 + ), 4994 4994 + ); 4278 4995 self.inner.unary(req, path, codec).await 4279 4996 } 4280 4997 pub async fn insert_playlist( 4281 4998 &mut self, 4282 4999 request: impl tonic::IntoRequest<super::InsertPlaylistRequest>, 4283 4283 - ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status> 4284 4284 - { 4285 4285 - self.inner.ready().await.map_err(|e| { 4286 4286 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4287 4287 - })?; 5000 5000 + ) -> std::result::Result< 5001 5001 + tonic::Response<super::InsertPlaylistResponse>, 5002 5002 + tonic::Status, 5003 5003 + > { 5004 5004 + self.inner 5005 5005 + .ready() 5006 5006 + .await 5007 5007 + .map_err(|e| { 5008 5008 + tonic::Status::unknown( 5009 5009 + format!("Service was not ready: {}", e.into()), 5010 5010 + ) 5011 5011 + })?; 4288 5012 let codec = tonic::codec::ProstCodec::default(); 4289 5013 let path = http::uri::PathAndQuery::from_static( 4290 5014 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist", 4291 5015 ); 4292 5016 let mut req = request.into_request(); 4293 4293 - req.extensions_mut().insert(GrpcMethod::new( 4294 4294 - "rockbox.v1alpha1.PlaylistService", 4295 4295 - "InsertPlaylist", 4296 4296 - )); 5017 5017 + req.extensions_mut() 5018 5018 + .insert( 5019 5019 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertPlaylist"), 5020 5020 + ); 4297 5021 self.inner.unary(req, path, codec).await 4298 5022 } 4299 5023 pub async fn insert_album( 4300 5024 &mut self, 4301 5025 request: impl tonic::IntoRequest<super::InsertAlbumRequest>, 4302 4302 - ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status> 4303 4303 - { 4304 4304 - self.inner.ready().await.map_err(|e| { 4305 4305 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4306 4306 - })?; 5026 5026 + ) -> std::result::Result< 5027 5027 + tonic::Response<super::InsertAlbumResponse>, 5028 5028 + tonic::Status, 5029 5029 + > { 5030 5030 + self.inner 5031 5031 + .ready() 5032 5032 + .await 5033 5033 + .map_err(|e| { 5034 5034 + tonic::Status::unknown( 5035 5035 + format!("Service was not ready: {}", e.into()), 5036 5036 + ) 5037 5037 + })?; 4307 5038 let codec = tonic::codec::ProstCodec::default(); 4308 5039 let path = http::uri::PathAndQuery::from_static( 4309 5040 "/rockbox.v1alpha1.PlaylistService/InsertAlbum", 4310 5041 ); 4311 5042 let mut req = request.into_request(); 4312 4312 - req.extensions_mut().insert(GrpcMethod::new( 4313 4313 - "rockbox.v1alpha1.PlaylistService", 4314 4314 - "InsertAlbum", 4315 4315 - )); 5043 5043 + req.extensions_mut() 5044 5044 + .insert( 5045 5045 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertAlbum"), 5046 5046 + ); 4316 5047 self.inner.unary(req, path, codec).await 4317 5048 } 4318 5049 pub async fn insert_artist_tracks( 4319 5050 &mut self, 4320 5051 request: impl tonic::IntoRequest<super::InsertArtistTracksRequest>, 4321 4321 - ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status> 4322 4322 - { 4323 4323 - self.inner.ready().await.map_err(|e| { 4324 4324 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4325 4325 - })?; 5052 5052 + ) -> std::result::Result< 5053 5053 + tonic::Response<super::InsertArtistTracksResponse>, 5054 5054 + tonic::Status, 5055 5055 + > { 5056 5056 + self.inner 5057 5057 + .ready() 5058 5058 + .await 5059 5059 + .map_err(|e| { 5060 5060 + tonic::Status::unknown( 5061 5061 + format!("Service was not ready: {}", e.into()), 5062 5062 + ) 5063 5063 + })?; 4326 5064 let codec = tonic::codec::ProstCodec::default(); 4327 5065 let path = http::uri::PathAndQuery::from_static( 4328 5066 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks", 4329 5067 ); 4330 5068 let mut req = request.into_request(); 4331 4331 - req.extensions_mut().insert(GrpcMethod::new( 4332 4332 - "rockbox.v1alpha1.PlaylistService", 4333 4333 - "InsertArtistTracks", 4334 4334 - )); 5069 5069 + req.extensions_mut() 5070 5070 + .insert( 5071 5071 + GrpcMethod::new( 5072 5072 + "rockbox.v1alpha1.PlaylistService", 5073 5073 + "InsertArtistTracks", 5074 5074 + ), 5075 5075 + ); 4335 5076 self.inner.unary(req, path, codec).await 4336 5077 } 4337 5078 pub async fn shuffle_playlist( 4338 5079 &mut self, 4339 5080 request: impl tonic::IntoRequest<super::ShufflePlaylistRequest>, 4340 4340 - ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status> 4341 4341 - { 4342 4342 - self.inner.ready().await.map_err(|e| { 4343 4343 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4344 4344 - })?; 5081 5081 + ) -> std::result::Result< 5082 5082 + tonic::Response<super::ShufflePlaylistResponse>, 5083 5083 + tonic::Status, 5084 5084 + > { 5085 5085 + self.inner 5086 5086 + .ready() 5087 5087 + .await 5088 5088 + .map_err(|e| { 5089 5089 + tonic::Status::unknown( 5090 5090 + format!("Service was not ready: {}", e.into()), 5091 5091 + ) 5092 5092 + })?; 4345 5093 let codec = tonic::codec::ProstCodec::default(); 4346 5094 let path = http::uri::PathAndQuery::from_static( 4347 5095 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist", 4348 5096 ); 4349 5097 let mut req = request.into_request(); 4350 4350 - req.extensions_mut().insert(GrpcMethod::new( 4351 4351 - "rockbox.v1alpha1.PlaylistService", 4352 4352 - "ShufflePlaylist", 4353 4353 - )); 5098 5098 + req.extensions_mut() 5099 5099 + .insert( 5100 5100 + GrpcMethod::new( 5101 5101 + "rockbox.v1alpha1.PlaylistService", 5102 5102 + "ShufflePlaylist", 5103 5103 + ), 5104 5104 + ); 4354 5105 self.inner.unary(req, path, codec).await 4355 5106 } 4356 5107 } ··· 4362 5113 dead_code, 4363 5114 missing_docs, 4364 5115 clippy::wildcard_imports, 4365 4365 - clippy::let_unit_value 5116 5116 + clippy::let_unit_value, 4366 5117 )] 4367 5118 use tonic::codegen::*; 4368 5119 /// Generated trait containing gRPC methods that should be implemented for use with PlaylistServiceServer. ··· 4371 5122 async fn get_current( 4372 5123 &self, 4373 5124 request: tonic::Request<super::GetCurrentRequest>, 4374 4374 - ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status>; 5125 5125 + ) -> std::result::Result< 5126 5126 + tonic::Response<super::GetCurrentResponse>, 5127 5127 + tonic::Status, 5128 5128 + >; 4375 5129 async fn get_resume_info( 4376 5130 &self, 4377 5131 request: tonic::Request<super::GetResumeInfoRequest>, 4378 4378 - ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status>; 5132 5132 + ) -> std::result::Result< 5133 5133 + tonic::Response<super::GetResumeInfoResponse>, 5134 5134 + tonic::Status, 5135 5135 + >; 4379 5136 async fn get_track_info( 4380 5137 &self, 4381 5138 request: tonic::Request<super::GetTrackInfoRequest>, 4382 4382 - ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status>; 5139 5139 + ) -> std::result::Result< 5140 5140 + tonic::Response<super::GetTrackInfoResponse>, 5141 5141 + tonic::Status, 5142 5142 + >; 4383 5143 async fn get_first_index( 4384 5144 &self, 4385 5145 request: tonic::Request<super::GetFirstIndexRequest>, 4386 4386 - ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status>; 5146 5146 + ) -> std::result::Result< 5147 5147 + tonic::Response<super::GetFirstIndexResponse>, 5148 5148 + tonic::Status, 5149 5149 + >; 4387 5150 async fn get_display_index( 4388 5151 &self, 4389 5152 request: tonic::Request<super::GetDisplayIndexRequest>, 4390 4390 - ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>; 5153 5153 + ) -> std::result::Result< 5154 5154 + tonic::Response<super::GetDisplayIndexResponse>, 5155 5155 + tonic::Status, 5156 5156 + >; 4391 5157 async fn amount( 4392 5158 &self, 4393 5159 request: tonic::Request<super::AmountRequest>, ··· 4395 5161 async fn playlist_resume( 4396 5162 &self, 4397 5163 request: tonic::Request<super::PlaylistResumeRequest>, 4398 4398 - ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status>; 5164 5164 + ) -> std::result::Result< 5165 5165 + tonic::Response<super::PlaylistResumeResponse>, 5166 5166 + tonic::Status, 5167 5167 + >; 4399 5168 async fn resume_track( 4400 5169 &self, 4401 5170 request: tonic::Request<super::ResumeTrackRequest>, 4402 4402 - ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status>; 5171 5171 + ) -> std::result::Result< 5172 5172 + tonic::Response<super::ResumeTrackResponse>, 5173 5173 + tonic::Status, 5174 5174 + >; 4403 5175 async fn set_modified( 4404 5176 &self, 4405 5177 request: tonic::Request<super::SetModifiedRequest>, 4406 4406 - ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>; 5178 5178 + ) -> std::result::Result< 5179 5179 + tonic::Response<super::SetModifiedResponse>, 5180 5180 + tonic::Status, 5181 5181 + >; 4407 5182 async fn start( 4408 5183 &self, 4409 5184 request: tonic::Request<super::StartRequest>, ··· 4415 5190 async fn remove_all_tracks( 4416 5191 &self, 4417 5192 request: tonic::Request<super::RemoveAllTracksRequest>, 4418 4418 - ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status>; 5193 5193 + ) -> std::result::Result< 5194 5194 + tonic::Response<super::RemoveAllTracksResponse>, 5195 5195 + tonic::Status, 5196 5196 + >; 4419 5197 async fn remove_tracks( 4420 5198 &self, 4421 5199 request: tonic::Request<super::RemoveTracksRequest>, 4422 4422 - ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status>; 5200 5200 + ) -> std::result::Result< 5201 5201 + tonic::Response<super::RemoveTracksResponse>, 5202 5202 + tonic::Status, 5203 5203 + >; 4423 5204 async fn create_playlist( 4424 5205 &self, 4425 5206 request: tonic::Request<super::CreatePlaylistRequest>, 4426 4426 - ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status>; 5207 5207 + ) -> std::result::Result< 5208 5208 + tonic::Response<super::CreatePlaylistResponse>, 5209 5209 + tonic::Status, 5210 5210 + >; 4427 5211 async fn insert_tracks( 4428 5212 &self, 4429 5213 request: tonic::Request<super::InsertTracksRequest>, 4430 4430 - ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status>; 5214 5214 + ) -> std::result::Result< 5215 5215 + tonic::Response<super::InsertTracksResponse>, 5216 5216 + tonic::Status, 5217 5217 + >; 4431 5218 async fn insert_directory( 4432 5219 &self, 4433 5220 request: tonic::Request<super::InsertDirectoryRequest>, 4434 4434 - ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status>; 5221 5221 + ) -> std::result::Result< 5222 5222 + tonic::Response<super::InsertDirectoryResponse>, 5223 5223 + tonic::Status, 5224 5224 + >; 4435 5225 async fn insert_playlist( 4436 5226 &self, 4437 5227 request: tonic::Request<super::InsertPlaylistRequest>, 4438 4438 - ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status>; 5228 5228 + ) -> std::result::Result< 5229 5229 + tonic::Response<super::InsertPlaylistResponse>, 5230 5230 + tonic::Status, 5231 5231 + >; 4439 5232 async fn insert_album( 4440 5233 &self, 4441 5234 request: tonic::Request<super::InsertAlbumRequest>, 4442 4442 - ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>; 5235 5235 + ) -> std::result::Result< 5236 5236 + tonic::Response<super::InsertAlbumResponse>, 5237 5237 + tonic::Status, 5238 5238 + >; 4443 5239 async fn insert_artist_tracks( 4444 5240 &self, 4445 5241 request: tonic::Request<super::InsertArtistTracksRequest>, 4446 4446 - ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>; 5242 5242 + ) -> std::result::Result< 5243 5243 + tonic::Response<super::InsertArtistTracksResponse>, 5244 5244 + tonic::Status, 5245 5245 + >; 4447 5246 async fn shuffle_playlist( 4448 5247 &self, 4449 5248 request: tonic::Request<super::ShufflePlaylistRequest>, 4450 4450 - ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>; 5249 5249 + ) -> std::result::Result< 5250 5250 + tonic::Response<super::ShufflePlaylistResponse>, 5251 5251 + tonic::Status, 5252 5252 + >; 4451 5253 } 4452 5254 #[derive(Debug)] 4453 5255 pub struct PlaylistServiceServer<T> { ··· 4470 5272 max_encoding_message_size: None, 4471 5273 } 4472 5274 } 4473 4473 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 5275 5275 + pub fn with_interceptor<F>( 5276 5276 + inner: T, 5277 5277 + interceptor: F, 5278 5278 + ) -> InterceptedService<Self, F> 4474 5279 where 4475 5280 F: tonic::service::Interceptor, 4476 5281 { ··· 4525 5330 "/rockbox.v1alpha1.PlaylistService/GetCurrent" => { 4526 5331 #[allow(non_camel_case_types)] 4527 5332 struct GetCurrentSvc<T: PlaylistService>(pub Arc<T>); 4528 4528 - impl<T: PlaylistService> tonic::server::UnaryService<super::GetCurrentRequest> 4529 4529 - for GetCurrentSvc<T> 4530 4530 - { 5333 5333 + impl< 5334 5334 + T: PlaylistService, 5335 5335 + > tonic::server::UnaryService<super::GetCurrentRequest> 5336 5336 + for GetCurrentSvc<T> { 4531 5337 type Response = super::GetCurrentResponse; 4532 4532 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5338 5338 + type Future = BoxFuture< 5339 5339 + tonic::Response<Self::Response>, 5340 5340 + tonic::Status, 5341 5341 + >; 4533 5342 fn call( 4534 5343 &mut self, 4535 5344 request: tonic::Request<super::GetCurrentRequest>, ··· 4566 5375 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo" => { 4567 5376 #[allow(non_camel_case_types)] 4568 5377 struct GetResumeInfoSvc<T: PlaylistService>(pub Arc<T>); 4569 4569 - impl<T: PlaylistService> 4570 4570 - tonic::server::UnaryService<super::GetResumeInfoRequest> 4571 4571 - for GetResumeInfoSvc<T> 4572 4572 - { 5378 5378 + impl< 5379 5379 + T: PlaylistService, 5380 5380 + > tonic::server::UnaryService<super::GetResumeInfoRequest> 5381 5381 + for GetResumeInfoSvc<T> { 4573 5382 type Response = super::GetResumeInfoResponse; 4574 4574 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5383 5383 + type Future = BoxFuture< 5384 5384 + tonic::Response<Self::Response>, 5385 5385 + tonic::Status, 5386 5386 + >; 4575 5387 fn call( 4576 5388 &mut self, 4577 5389 request: tonic::Request<super::GetResumeInfoRequest>, 4578 5390 ) -> Self::Future { 4579 5391 let inner = Arc::clone(&self.0); 4580 5392 let fut = async move { 4581 4581 - <T as PlaylistService>::get_resume_info(&inner, request).await 5393 5393 + <T as PlaylistService>::get_resume_info(&inner, request) 5394 5394 + .await 4582 5395 }; 4583 5396 Box::pin(fut) 4584 5397 } ··· 4608 5421 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo" => { 4609 5422 #[allow(non_camel_case_types)] 4610 5423 struct GetTrackInfoSvc<T: PlaylistService>(pub Arc<T>); 4611 4611 - impl<T: PlaylistService> tonic::server::UnaryService<super::GetTrackInfoRequest> 4612 4612 - for GetTrackInfoSvc<T> 4613 4613 - { 5424 5424 + impl< 5425 5425 + T: PlaylistService, 5426 5426 + > tonic::server::UnaryService<super::GetTrackInfoRequest> 5427 5427 + for GetTrackInfoSvc<T> { 4614 5428 type Response = super::GetTrackInfoResponse; 4615 4615 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5429 5429 + type Future = BoxFuture< 5430 5430 + tonic::Response<Self::Response>, 5431 5431 + tonic::Status, 5432 5432 + >; 4616 5433 fn call( 4617 5434 &mut self, 4618 5435 request: tonic::Request<super::GetTrackInfoRequest>, 4619 5436 ) -> Self::Future { 4620 5437 let inner = Arc::clone(&self.0); 4621 5438 let fut = async move { 4622 4622 - <T as PlaylistService>::get_track_info(&inner, request).await 5439 5439 + <T as PlaylistService>::get_track_info(&inner, request) 5440 5440 + .await 4623 5441 }; 4624 5442 Box::pin(fut) 4625 5443 } ··· 4649 5467 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex" => { 4650 5468 #[allow(non_camel_case_types)] 4651 5469 struct GetFirstIndexSvc<T: PlaylistService>(pub Arc<T>); 4652 4652 - impl<T: PlaylistService> 4653 4653 - tonic::server::UnaryService<super::GetFirstIndexRequest> 4654 4654 - for GetFirstIndexSvc<T> 4655 4655 - { 5470 5470 + impl< 5471 5471 + T: PlaylistService, 5472 5472 + > tonic::server::UnaryService<super::GetFirstIndexRequest> 5473 5473 + for GetFirstIndexSvc<T> { 4656 5474 type Response = super::GetFirstIndexResponse; 4657 4657 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5475 5475 + type Future = BoxFuture< 5476 5476 + tonic::Response<Self::Response>, 5477 5477 + tonic::Status, 5478 5478 + >; 4658 5479 fn call( 4659 5480 &mut self, 4660 5481 request: tonic::Request<super::GetFirstIndexRequest>, 4661 5482 ) -> Self::Future { 4662 5483 let inner = Arc::clone(&self.0); 4663 5484 let fut = async move { 4664 4664 - <T as PlaylistService>::get_first_index(&inner, request).await 5485 5485 + <T as PlaylistService>::get_first_index(&inner, request) 5486 5486 + .await 4665 5487 }; 4666 5488 Box::pin(fut) 4667 5489 } ··· 4691 5513 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex" => { 4692 5514 #[allow(non_camel_case_types)] 4693 5515 struct GetDisplayIndexSvc<T: PlaylistService>(pub Arc<T>); 4694 4694 - impl<T: PlaylistService> 4695 4695 - tonic::server::UnaryService<super::GetDisplayIndexRequest> 4696 4696 - for GetDisplayIndexSvc<T> 4697 4697 - { 5516 5516 + impl< 5517 5517 + T: PlaylistService, 5518 5518 + > tonic::server::UnaryService<super::GetDisplayIndexRequest> 5519 5519 + for GetDisplayIndexSvc<T> { 4698 5520 type Response = super::GetDisplayIndexResponse; 4699 4699 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5521 5521 + type Future = BoxFuture< 5522 5522 + tonic::Response<Self::Response>, 5523 5523 + tonic::Status, 5524 5524 + >; 4700 5525 fn call( 4701 5526 &mut self, 4702 5527 request: tonic::Request<super::GetDisplayIndexRequest>, 4703 5528 ) -> Self::Future { 4704 5529 let inner = Arc::clone(&self.0); 4705 5530 let fut = async move { 4706 4706 - <T as PlaylistService>::get_display_index(&inner, request).await 5531 5531 + <T as PlaylistService>::get_display_index(&inner, request) 5532 5532 + .await 4707 5533 }; 4708 5534 Box::pin(fut) 4709 5535 } ··· 4733 5559 "/rockbox.v1alpha1.PlaylistService/Amount" => { 4734 5560 #[allow(non_camel_case_types)] 4735 5561 struct AmountSvc<T: PlaylistService>(pub Arc<T>); 4736 4736 - impl<T: PlaylistService> tonic::server::UnaryService<super::AmountRequest> for AmountSvc<T> { 5562 5562 + impl< 5563 5563 + T: PlaylistService, 5564 5564 + > tonic::server::UnaryService<super::AmountRequest> 5565 5565 + for AmountSvc<T> { 4737 5566 type Response = super::AmountResponse; 4738 4738 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5567 5567 + type Future = BoxFuture< 5568 5568 + tonic::Response<Self::Response>, 5569 5569 + tonic::Status, 5570 5570 + >; 4739 5571 fn call( 4740 5572 &mut self, 4741 5573 request: tonic::Request<super::AmountRequest>, ··· 4772 5604 "/rockbox.v1alpha1.PlaylistService/PlaylistResume" => { 4773 5605 #[allow(non_camel_case_types)] 4774 5606 struct PlaylistResumeSvc<T: PlaylistService>(pub Arc<T>); 4775 4775 - impl<T: PlaylistService> 4776 4776 - tonic::server::UnaryService<super::PlaylistResumeRequest> 4777 4777 - for PlaylistResumeSvc<T> 4778 4778 - { 5607 5607 + impl< 5608 5608 + T: PlaylistService, 5609 5609 + > tonic::server::UnaryService<super::PlaylistResumeRequest> 5610 5610 + for PlaylistResumeSvc<T> { 4779 5611 type Response = super::PlaylistResumeResponse; 4780 4780 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5612 5612 + type Future = BoxFuture< 5613 5613 + tonic::Response<Self::Response>, 5614 5614 + tonic::Status, 5615 5615 + >; 4781 5616 fn call( 4782 5617 &mut self, 4783 5618 request: tonic::Request<super::PlaylistResumeRequest>, 4784 5619 ) -> Self::Future { 4785 5620 let inner = Arc::clone(&self.0); 4786 5621 let fut = async move { 4787 4787 - <T as PlaylistService>::playlist_resume(&inner, request).await 5622 5622 + <T as PlaylistService>::playlist_resume(&inner, request) 5623 5623 + .await 4788 5624 }; 4789 5625 Box::pin(fut) 4790 5626 } ··· 4814 5650 "/rockbox.v1alpha1.PlaylistService/ResumeTrack" => { 4815 5651 #[allow(non_camel_case_types)] 4816 5652 struct ResumeTrackSvc<T: PlaylistService>(pub Arc<T>); 4817 4817 - impl<T: PlaylistService> tonic::server::UnaryService<super::ResumeTrackRequest> 4818 4818 - for ResumeTrackSvc<T> 4819 4819 - { 5653 5653 + impl< 5654 5654 + T: PlaylistService, 5655 5655 + > tonic::server::UnaryService<super::ResumeTrackRequest> 5656 5656 + for ResumeTrackSvc<T> { 4820 5657 type Response = super::ResumeTrackResponse; 4821 4821 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5658 5658 + type Future = BoxFuture< 5659 5659 + tonic::Response<Self::Response>, 5660 5660 + tonic::Status, 5661 5661 + >; 4822 5662 fn call( 4823 5663 &mut self, 4824 5664 request: tonic::Request<super::ResumeTrackRequest>, ··· 4855 5695 "/rockbox.v1alpha1.PlaylistService/SetModified" => { 4856 5696 #[allow(non_camel_case_types)] 4857 5697 struct SetModifiedSvc<T: PlaylistService>(pub Arc<T>); 4858 4858 - impl<T: PlaylistService> tonic::server::UnaryService<super::SetModifiedRequest> 4859 4859 - for SetModifiedSvc<T> 4860 4860 - { 5698 5698 + impl< 5699 5699 + T: PlaylistService, 5700 5700 + > tonic::server::UnaryService<super::SetModifiedRequest> 5701 5701 + for SetModifiedSvc<T> { 4861 5702 type Response = super::SetModifiedResponse; 4862 4862 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5703 5703 + type Future = BoxFuture< 5704 5704 + tonic::Response<Self::Response>, 5705 5705 + tonic::Status, 5706 5706 + >; 4863 5707 fn call( 4864 5708 &mut self, 4865 5709 request: tonic::Request<super::SetModifiedRequest>, ··· 4896 5740 "/rockbox.v1alpha1.PlaylistService/Start" => { 4897 5741 #[allow(non_camel_case_types)] 4898 5742 struct StartSvc<T: PlaylistService>(pub Arc<T>); 4899 4899 - impl<T: PlaylistService> tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 5743 5743 + impl< 5744 5744 + T: PlaylistService, 5745 5745 + > tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 4900 5746 type Response = super::StartResponse; 4901 4901 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5747 5747 + type Future = BoxFuture< 5748 5748 + tonic::Response<Self::Response>, 5749 5749 + tonic::Status, 5750 5750 + >; 4902 5751 fn call( 4903 5752 &mut self, 4904 5753 request: tonic::Request<super::StartRequest>, 4905 5754 ) -> Self::Future { 4906 5755 let inner = Arc::clone(&self.0); 4907 4907 - let fut = 4908 4908 - async move { <T as PlaylistService>::start(&inner, request).await }; 5756 5756 + let fut = async move { 5757 5757 + <T as PlaylistService>::start(&inner, request).await 5758 5758 + }; 4909 5759 Box::pin(fut) 4910 5760 } 4911 5761 } ··· 4934 5784 "/rockbox.v1alpha1.PlaylistService/Sync" => { 4935 5785 #[allow(non_camel_case_types)] 4936 5786 struct SyncSvc<T: PlaylistService>(pub Arc<T>); 4937 4937 - impl<T: PlaylistService> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 5787 5787 + impl< 5788 5788 + T: PlaylistService, 5789 5789 + > tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 4938 5790 type Response = super::SyncResponse; 4939 4939 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5791 5791 + type Future = BoxFuture< 5792 5792 + tonic::Response<Self::Response>, 5793 5793 + tonic::Status, 5794 5794 + >; 4940 5795 fn call( 4941 5796 &mut self, 4942 5797 request: tonic::Request<super::SyncRequest>, 4943 5798 ) -> Self::Future { 4944 5799 let inner = Arc::clone(&self.0); 4945 4945 - let fut = 4946 4946 - async move { <T as PlaylistService>::sync(&inner, request).await }; 5800 5800 + let fut = async move { 5801 5801 + <T as PlaylistService>::sync(&inner, request).await 5802 5802 + }; 4947 5803 Box::pin(fut) 4948 5804 } 4949 5805 } ··· 4972 5828 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks" => { 4973 5829 #[allow(non_camel_case_types)] 4974 5830 struct RemoveAllTracksSvc<T: PlaylistService>(pub Arc<T>); 4975 4975 - impl<T: PlaylistService> 4976 4976 - tonic::server::UnaryService<super::RemoveAllTracksRequest> 4977 4977 - for RemoveAllTracksSvc<T> 4978 4978 - { 5831 5831 + impl< 5832 5832 + T: PlaylistService, 5833 5833 + > tonic::server::UnaryService<super::RemoveAllTracksRequest> 5834 5834 + for RemoveAllTracksSvc<T> { 4979 5835 type Response = super::RemoveAllTracksResponse; 4980 4980 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5836 5836 + type Future = BoxFuture< 5837 5837 + tonic::Response<Self::Response>, 5838 5838 + tonic::Status, 5839 5839 + >; 4981 5840 fn call( 4982 5841 &mut self, 4983 5842 request: tonic::Request<super::RemoveAllTracksRequest>, 4984 5843 ) -> Self::Future { 4985 5844 let inner = Arc::clone(&self.0); 4986 5845 let fut = async move { 4987 4987 - <T as PlaylistService>::remove_all_tracks(&inner, request).await 5846 5846 + <T as PlaylistService>::remove_all_tracks(&inner, request) 5847 5847 + .await 4988 5848 }; 4989 5849 Box::pin(fut) 4990 5850 } ··· 5014 5874 "/rockbox.v1alpha1.PlaylistService/RemoveTracks" => { 5015 5875 #[allow(non_camel_case_types)] 5016 5876 struct RemoveTracksSvc<T: PlaylistService>(pub Arc<T>); 5017 5017 - impl<T: PlaylistService> tonic::server::UnaryService<super::RemoveTracksRequest> 5018 5018 - for RemoveTracksSvc<T> 5019 5019 - { 5877 5877 + impl< 5878 5878 + T: PlaylistService, 5879 5879 + > tonic::server::UnaryService<super::RemoveTracksRequest> 5880 5880 + for RemoveTracksSvc<T> { 5020 5881 type Response = super::RemoveTracksResponse; 5021 5021 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5882 5882 + type Future = BoxFuture< 5883 5883 + tonic::Response<Self::Response>, 5884 5884 + tonic::Status, 5885 5885 + >; 5022 5886 fn call( 5023 5887 &mut self, 5024 5888 request: tonic::Request<super::RemoveTracksRequest>, ··· 5055 5919 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist" => { 5056 5920 #[allow(non_camel_case_types)] 5057 5921 struct CreatePlaylistSvc<T: PlaylistService>(pub Arc<T>); 5058 5058 - impl<T: PlaylistService> 5059 5059 - tonic::server::UnaryService<super::CreatePlaylistRequest> 5060 5060 - for CreatePlaylistSvc<T> 5061 5061 - { 5922 5922 + impl< 5923 5923 + T: PlaylistService, 5924 5924 + > tonic::server::UnaryService<super::CreatePlaylistRequest> 5925 5925 + for CreatePlaylistSvc<T> { 5062 5926 type Response = super::CreatePlaylistResponse; 5063 5063 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5927 5927 + type Future = BoxFuture< 5928 5928 + tonic::Response<Self::Response>, 5929 5929 + tonic::Status, 5930 5930 + >; 5064 5931 fn call( 5065 5932 &mut self, 5066 5933 request: tonic::Request<super::CreatePlaylistRequest>, 5067 5934 ) -> Self::Future { 5068 5935 let inner = Arc::clone(&self.0); 5069 5936 let fut = async move { 5070 5070 - <T as PlaylistService>::create_playlist(&inner, request).await 5937 5937 + <T as PlaylistService>::create_playlist(&inner, request) 5938 5938 + .await 5071 5939 }; 5072 5940 Box::pin(fut) 5073 5941 } ··· 5097 5965 "/rockbox.v1alpha1.PlaylistService/InsertTracks" => { 5098 5966 #[allow(non_camel_case_types)] 5099 5967 struct InsertTracksSvc<T: PlaylistService>(pub Arc<T>); 5100 5100 - impl<T: PlaylistService> tonic::server::UnaryService<super::InsertTracksRequest> 5101 5101 - for InsertTracksSvc<T> 5102 5102 - { 5968 5968 + impl< 5969 5969 + T: PlaylistService, 5970 5970 + > tonic::server::UnaryService<super::InsertTracksRequest> 5971 5971 + for InsertTracksSvc<T> { 5103 5972 type Response = super::InsertTracksResponse; 5104 5104 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5973 5973 + type Future = BoxFuture< 5974 5974 + tonic::Response<Self::Response>, 5975 5975 + tonic::Status, 5976 5976 + >; 5105 5977 fn call( 5106 5978 &mut self, 5107 5979 request: tonic::Request<super::InsertTracksRequest>, ··· 5138 6010 "/rockbox.v1alpha1.PlaylistService/InsertDirectory" => { 5139 6011 #[allow(non_camel_case_types)] 5140 6012 struct InsertDirectorySvc<T: PlaylistService>(pub Arc<T>); 5141 5141 - impl<T: PlaylistService> 5142 5142 - tonic::server::UnaryService<super::InsertDirectoryRequest> 5143 5143 - for InsertDirectorySvc<T> 5144 5144 - { 6013 6013 + impl< 6014 6014 + T: PlaylistService, 6015 6015 + > tonic::server::UnaryService<super::InsertDirectoryRequest> 6016 6016 + for InsertDirectorySvc<T> { 5145 6017 type Response = super::InsertDirectoryResponse; 5146 5146 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6018 6018 + type Future = BoxFuture< 6019 6019 + tonic::Response<Self::Response>, 6020 6020 + tonic::Status, 6021 6021 + >; 5147 6022 fn call( 5148 6023 &mut self, 5149 6024 request: tonic::Request<super::InsertDirectoryRequest>, 5150 6025 ) -> Self::Future { 5151 6026 let inner = Arc::clone(&self.0); 5152 6027 let fut = async move { 5153 5153 - <T as PlaylistService>::insert_directory(&inner, request).await 6028 6028 + <T as PlaylistService>::insert_directory(&inner, request) 6029 6029 + .await 5154 6030 }; 5155 6031 Box::pin(fut) 5156 6032 } ··· 5180 6056 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist" => { 5181 6057 #[allow(non_camel_case_types)] 5182 6058 struct InsertPlaylistSvc<T: PlaylistService>(pub Arc<T>); 5183 5183 - impl<T: PlaylistService> 5184 5184 - tonic::server::UnaryService<super::InsertPlaylistRequest> 5185 5185 - for InsertPlaylistSvc<T> 5186 5186 - { 6059 6059 + impl< 6060 6060 + T: PlaylistService, 6061 6061 + > tonic::server::UnaryService<super::InsertPlaylistRequest> 6062 6062 + for InsertPlaylistSvc<T> { 5187 6063 type Response = super::InsertPlaylistResponse; 5188 5188 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6064 6064 + type Future = BoxFuture< 6065 6065 + tonic::Response<Self::Response>, 6066 6066 + tonic::Status, 6067 6067 + >; 5189 6068 fn call( 5190 6069 &mut self, 5191 6070 request: tonic::Request<super::InsertPlaylistRequest>, 5192 6071 ) -> Self::Future { 5193 6072 let inner = Arc::clone(&self.0); 5194 6073 let fut = async move { 5195 5195 - <T as PlaylistService>::insert_playlist(&inner, request).await 6074 6074 + <T as PlaylistService>::insert_playlist(&inner, request) 6075 6075 + .await 5196 6076 }; 5197 6077 Box::pin(fut) 5198 6078 } ··· 5222 6102 "/rockbox.v1alpha1.PlaylistService/InsertAlbum" => { 5223 6103 #[allow(non_camel_case_types)] 5224 6104 struct InsertAlbumSvc<T: PlaylistService>(pub Arc<T>); 5225 5225 - impl<T: PlaylistService> tonic::server::UnaryService<super::InsertAlbumRequest> 5226 5226 - for InsertAlbumSvc<T> 5227 5227 - { 6105 6105 + impl< 6106 6106 + T: PlaylistService, 6107 6107 + > tonic::server::UnaryService<super::InsertAlbumRequest> 6108 6108 + for InsertAlbumSvc<T> { 5228 6109 type Response = super::InsertAlbumResponse; 5229 5229 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6110 6110 + type Future = BoxFuture< 6111 6111 + tonic::Response<Self::Response>, 6112 6112 + tonic::Status, 6113 6113 + >; 5230 6114 fn call( 5231 6115 &mut self, 5232 6116 request: tonic::Request<super::InsertAlbumRequest>, ··· 5263 6147 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks" => { 5264 6148 #[allow(non_camel_case_types)] 5265 6149 struct InsertArtistTracksSvc<T: PlaylistService>(pub Arc<T>); 5266 5266 - impl<T: PlaylistService> 5267 5267 - tonic::server::UnaryService<super::InsertArtistTracksRequest> 5268 5268 - for InsertArtistTracksSvc<T> 5269 5269 - { 6150 6150 + impl< 6151 6151 + T: PlaylistService, 6152 6152 + > tonic::server::UnaryService<super::InsertArtistTracksRequest> 6153 6153 + for InsertArtistTracksSvc<T> { 5270 6154 type Response = super::InsertArtistTracksResponse; 5271 5271 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6155 6155 + type Future = BoxFuture< 6156 6156 + tonic::Response<Self::Response>, 6157 6157 + tonic::Status, 6158 6158 + >; 5272 6159 fn call( 5273 6160 &mut self, 5274 6161 request: tonic::Request<super::InsertArtistTracksRequest>, 5275 6162 ) -> Self::Future { 5276 6163 let inner = Arc::clone(&self.0); 5277 6164 let fut = async move { 5278 5278 - <T as PlaylistService>::insert_artist_tracks(&inner, request).await 6165 6165 + <T as PlaylistService>::insert_artist_tracks( 6166 6166 + &inner, 6167 6167 + request, 6168 6168 + ) 6169 6169 + .await 5279 6170 }; 5280 6171 Box::pin(fut) 5281 6172 } ··· 5305 6196 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist" => { 5306 6197 #[allow(non_camel_case_types)] 5307 6198 struct ShufflePlaylistSvc<T: PlaylistService>(pub Arc<T>); 5308 5308 - impl<T: PlaylistService> 5309 5309 - tonic::server::UnaryService<super::ShufflePlaylistRequest> 5310 5310 - for ShufflePlaylistSvc<T> 5311 5311 - { 6199 6199 + impl< 6200 6200 + T: PlaylistService, 6201 6201 + > tonic::server::UnaryService<super::ShufflePlaylistRequest> 6202 6202 + for ShufflePlaylistSvc<T> { 5312 6203 type Response = super::ShufflePlaylistResponse; 5313 5313 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6204 6204 + type Future = BoxFuture< 6205 6205 + tonic::Response<Self::Response>, 6206 6206 + tonic::Status, 6207 6207 + >; 5314 6208 fn call( 5315 6209 &mut self, 5316 6210 request: tonic::Request<super::ShufflePlaylistRequest>, 5317 6211 ) -> Self::Future { 5318 6212 let inner = Arc::clone(&self.0); 5319 6213 let fut = async move { 5320 5320 - <T as PlaylistService>::shuffle_playlist(&inner, request).await 6214 6214 + <T as PlaylistService>::shuffle_playlist(&inner, request) 6215 6215 + .await 5321 6216 }; 5322 6217 Box::pin(fut) 5323 6218 } ··· 5344 6239 }; 5345 6240 Box::pin(fut) 5346 6241 } 5347 5347 - _ => Box::pin(async move { 5348 5348 - let mut response = http::Response::new(empty_body()); 5349 5349 - let headers = response.headers_mut(); 5350 5350 - headers.insert( 5351 5351 - tonic::Status::GRPC_STATUS, 5352 5352 - (tonic::Code::Unimplemented as i32).into(), 5353 5353 - ); 5354 5354 - headers.insert( 5355 5355 - http::header::CONTENT_TYPE, 5356 5356 - tonic::metadata::GRPC_CONTENT_TYPE, 5357 5357 - ); 5358 5358 - Ok(response) 5359 5359 - }), 6242 6242 + _ => { 6243 6243 + Box::pin(async move { 6244 6244 + let mut response = http::Response::new(empty_body()); 6245 6245 + let headers = response.headers_mut(); 6246 6246 + headers 6247 6247 + .insert( 6248 6248 + tonic::Status::GRPC_STATUS, 6249 6249 + (tonic::Code::Unimplemented as i32).into(), 6250 6250 + ); 6251 6251 + headers 6252 6252 + .insert( 6253 6253 + http::header::CONTENT_TYPE, 6254 6254 + tonic::metadata::GRPC_CONTENT_TYPE, 6255 6255 + ); 6256 6256 + Ok(response) 6257 6257 + }) 6258 6258 + } 5360 6259 } 5361 6260 } 5362 6261 } ··· 5864 6763 dead_code, 5865 6764 missing_docs, 5866 6765 clippy::wildcard_imports, 5867 5867 - clippy::let_unit_value 6766 6766 + clippy::let_unit_value, 5868 6767 )] 5869 5869 - use tonic::codegen::http::Uri; 5870 6768 use tonic::codegen::*; 6769 6769 + use tonic::codegen::http::Uri; 5871 6770 #[derive(Debug, Clone)] 5872 6771 pub struct SettingsServiceClient<T> { 5873 6772 inner: tonic::client::Grpc<T>, ··· 5911 6810 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 5912 6811 >, 5913 6812 >, 5914 5914 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 5915 5915 - Into<StdError> + std::marker::Send + std::marker::Sync, 6813 6813 + <T as tonic::codegen::Service< 6814 6814 + http::Request<tonic::body::BoxBody>, 6815 6815 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 5916 6816 { 5917 6817 SettingsServiceClient::new(InterceptedService::new(inner, interceptor)) 5918 6818 } ··· 5950 6850 pub async fn get_settings_list( 5951 6851 &mut self, 5952 6852 request: impl tonic::IntoRequest<super::GetSettingsListRequest>, 5953 5953 - ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status> 5954 5954 - { 5955 5955 - self.inner.ready().await.map_err(|e| { 5956 5956 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 5957 5957 - })?; 6853 6853 + ) -> std::result::Result< 6854 6854 + tonic::Response<super::GetSettingsListResponse>, 6855 6855 + tonic::Status, 6856 6856 + > { 6857 6857 + self.inner 6858 6858 + .ready() 6859 6859 + .await 6860 6860 + .map_err(|e| { 6861 6861 + tonic::Status::unknown( 6862 6862 + format!("Service was not ready: {}", e.into()), 6863 6863 + ) 6864 6864 + })?; 5958 6865 let codec = tonic::codec::ProstCodec::default(); 5959 6866 let path = http::uri::PathAndQuery::from_static( 5960 6867 "/rockbox.v1alpha1.SettingsService/GetSettingsList", 5961 6868 ); 5962 6869 let mut req = request.into_request(); 5963 5963 - req.extensions_mut().insert(GrpcMethod::new( 5964 5964 - "rockbox.v1alpha1.SettingsService", 5965 5965 - "GetSettingsList", 5966 5966 - )); 6870 6870 + req.extensions_mut() 6871 6871 + .insert( 6872 6872 + GrpcMethod::new( 6873 6873 + "rockbox.v1alpha1.SettingsService", 6874 6874 + "GetSettingsList", 6875 6875 + ), 6876 6876 + ); 5967 6877 self.inner.unary(req, path, codec).await 5968 6878 } 5969 6879 pub async fn get_global_settings( 5970 6880 &mut self, 5971 6881 request: impl tonic::IntoRequest<super::GetGlobalSettingsRequest>, 5972 5972 - ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status> 5973 5973 - { 5974 5974 - self.inner.ready().await.map_err(|e| { 5975 5975 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 5976 5976 - })?; 6882 6882 + ) -> std::result::Result< 6883 6883 + tonic::Response<super::GetGlobalSettingsResponse>, 6884 6884 + tonic::Status, 6885 6885 + > { 6886 6886 + self.inner 6887 6887 + .ready() 6888 6888 + .await 6889 6889 + .map_err(|e| { 6890 6890 + tonic::Status::unknown( 6891 6891 + format!("Service was not ready: {}", e.into()), 6892 6892 + ) 6893 6893 + })?; 5977 6894 let codec = tonic::codec::ProstCodec::default(); 5978 6895 let path = http::uri::PathAndQuery::from_static( 5979 6896 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings", 5980 6897 ); 5981 6898 let mut req = request.into_request(); 5982 5982 - req.extensions_mut().insert(GrpcMethod::new( 5983 5983 - "rockbox.v1alpha1.SettingsService", 5984 5984 - "GetGlobalSettings", 5985 5985 - )); 6899 6899 + req.extensions_mut() 6900 6900 + .insert( 6901 6901 + GrpcMethod::new( 6902 6902 + "rockbox.v1alpha1.SettingsService", 6903 6903 + "GetGlobalSettings", 6904 6904 + ), 6905 6905 + ); 5986 6906 self.inner.unary(req, path, codec).await 5987 6907 } 5988 6908 pub async fn save_settings( 5989 6909 &mut self, 5990 6910 request: impl tonic::IntoRequest<super::SaveSettingsRequest>, 5991 5991 - ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status> 5992 5992 - { 5993 5993 - self.inner.ready().await.map_err(|e| { 5994 5994 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 5995 5995 - })?; 6911 6911 + ) -> std::result::Result< 6912 6912 + tonic::Response<super::SaveSettingsResponse>, 6913 6913 + tonic::Status, 6914 6914 + > { 6915 6915 + self.inner 6916 6916 + .ready() 6917 6917 + .await 6918 6918 + .map_err(|e| { 6919 6919 + tonic::Status::unknown( 6920 6920 + format!("Service was not ready: {}", e.into()), 6921 6921 + ) 6922 6922 + })?; 5996 6923 let codec = tonic::codec::ProstCodec::default(); 5997 6924 let path = http::uri::PathAndQuery::from_static( 5998 6925 "/rockbox.v1alpha1.SettingsService/SaveSettings", 5999 6926 ); 6000 6927 let mut req = request.into_request(); 6001 6001 - req.extensions_mut().insert(GrpcMethod::new( 6002 6002 - "rockbox.v1alpha1.SettingsService", 6003 6003 - "SaveSettings", 6004 6004 - )); 6928 6928 + req.extensions_mut() 6929 6929 + .insert( 6930 6930 + GrpcMethod::new("rockbox.v1alpha1.SettingsService", "SaveSettings"), 6931 6931 + ); 6005 6932 self.inner.unary(req, path, codec).await 6006 6933 } 6007 6934 } ··· 6013 6940 dead_code, 6014 6941 missing_docs, 6015 6942 clippy::wildcard_imports, 6016 6016 - clippy::let_unit_value 6943 6943 + clippy::let_unit_value, 6017 6944 )] 6018 6945 use tonic::codegen::*; 6019 6946 /// Generated trait containing gRPC methods that should be implemented for use with SettingsServiceServer. ··· 6022 6949 async fn get_settings_list( 6023 6950 &self, 6024 6951 request: tonic::Request<super::GetSettingsListRequest>, 6025 6025 - ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status>; 6952 6952 + ) -> std::result::Result< 6953 6953 + tonic::Response<super::GetSettingsListResponse>, 6954 6954 + tonic::Status, 6955 6955 + >; 6026 6956 async fn get_global_settings( 6027 6957 &self, 6028 6958 request: tonic::Request<super::GetGlobalSettingsRequest>, 6029 6029 - ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status>; 6959 6959 + ) -> std::result::Result< 6960 6960 + tonic::Response<super::GetGlobalSettingsResponse>, 6961 6961 + tonic::Status, 6962 6962 + >; 6030 6963 async fn save_settings( 6031 6964 &self, 6032 6965 request: tonic::Request<super::SaveSettingsRequest>, 6033 6033 - ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>; 6966 6966 + ) -> std::result::Result< 6967 6967 + tonic::Response<super::SaveSettingsResponse>, 6968 6968 + tonic::Status, 6969 6969 + >; 6034 6970 } 6035 6971 #[derive(Debug)] 6036 6972 pub struct SettingsServiceServer<T> { ··· 6053 6989 max_encoding_message_size: None, 6054 6990 } 6055 6991 } 6056 6056 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 6992 6992 + pub fn with_interceptor<F>( 6993 6993 + inner: T, 6994 6994 + interceptor: F, 6995 6995 + ) -> InterceptedService<Self, F> 6057 6996 where 6058 6997 F: tonic::service::Interceptor, 6059 6998 { ··· 6108 7047 "/rockbox.v1alpha1.SettingsService/GetSettingsList" => { 6109 7048 #[allow(non_camel_case_types)] 6110 7049 struct GetSettingsListSvc<T: SettingsService>(pub Arc<T>); 6111 6111 - impl<T: SettingsService> 6112 6112 - tonic::server::UnaryService<super::GetSettingsListRequest> 6113 6113 - for GetSettingsListSvc<T> 6114 6114 - { 7050 7050 + impl< 7051 7051 + T: SettingsService, 7052 7052 + > tonic::server::UnaryService<super::GetSettingsListRequest> 7053 7053 + for GetSettingsListSvc<T> { 6115 7054 type Response = super::GetSettingsListResponse; 6116 6116 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7055 7055 + type Future = BoxFuture< 7056 7056 + tonic::Response<Self::Response>, 7057 7057 + tonic::Status, 7058 7058 + >; 6117 7059 fn call( 6118 7060 &mut self, 6119 7061 request: tonic::Request<super::GetSettingsListRequest>, 6120 7062 ) -> Self::Future { 6121 7063 let inner = Arc::clone(&self.0); 6122 7064 let fut = async move { 6123 6123 - <T as SettingsService>::get_settings_list(&inner, request).await 7065 7065 + <T as SettingsService>::get_settings_list(&inner, request) 7066 7066 + .await 6124 7067 }; 6125 7068 Box::pin(fut) 6126 7069 } ··· 6150 7093 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings" => { 6151 7094 #[allow(non_camel_case_types)] 6152 7095 struct GetGlobalSettingsSvc<T: SettingsService>(pub Arc<T>); 6153 6153 - impl<T: SettingsService> 6154 6154 - tonic::server::UnaryService<super::GetGlobalSettingsRequest> 6155 6155 - for GetGlobalSettingsSvc<T> 6156 6156 - { 7096 7096 + impl< 7097 7097 + T: SettingsService, 7098 7098 + > tonic::server::UnaryService<super::GetGlobalSettingsRequest> 7099 7099 + for GetGlobalSettingsSvc<T> { 6157 7100 type Response = super::GetGlobalSettingsResponse; 6158 6158 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7101 7101 + type Future = BoxFuture< 7102 7102 + tonic::Response<Self::Response>, 7103 7103 + tonic::Status, 7104 7104 + >; 6159 7105 fn call( 6160 7106 &mut self, 6161 7107 request: tonic::Request<super::GetGlobalSettingsRequest>, 6162 7108 ) -> Self::Future { 6163 7109 let inner = Arc::clone(&self.0); 6164 7110 let fut = async move { 6165 6165 - <T as SettingsService>::get_global_settings(&inner, request).await 7111 7111 + <T as SettingsService>::get_global_settings(&inner, request) 7112 7112 + .await 6166 7113 }; 6167 7114 Box::pin(fut) 6168 7115 } ··· 6192 7139 "/rockbox.v1alpha1.SettingsService/SaveSettings" => { 6193 7140 #[allow(non_camel_case_types)] 6194 7141 struct SaveSettingsSvc<T: SettingsService>(pub Arc<T>); 6195 6195 - impl<T: SettingsService> tonic::server::UnaryService<super::SaveSettingsRequest> 6196 6196 - for SaveSettingsSvc<T> 6197 6197 - { 7142 7142 + impl< 7143 7143 + T: SettingsService, 7144 7144 + > tonic::server::UnaryService<super::SaveSettingsRequest> 7145 7145 + for SaveSettingsSvc<T> { 6198 7146 type Response = super::SaveSettingsResponse; 6199 6199 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7147 7147 + type Future = BoxFuture< 7148 7148 + tonic::Response<Self::Response>, 7149 7149 + tonic::Status, 7150 7150 + >; 6200 7151 fn call( 6201 7152 &mut self, 6202 7153 request: tonic::Request<super::SaveSettingsRequest>, ··· 6230 7181 }; 6231 7182 Box::pin(fut) 6232 7183 } 6233 6233 - _ => Box::pin(async move { 6234 6234 - let mut response = http::Response::new(empty_body()); 6235 6235 - let headers = response.headers_mut(); 6236 6236 - headers.insert( 6237 6237 - tonic::Status::GRPC_STATUS, 6238 6238 - (tonic::Code::Unimplemented as i32).into(), 6239 6239 - ); 6240 6240 - headers.insert( 6241 6241 - http::header::CONTENT_TYPE, 6242 6242 - tonic::metadata::GRPC_CONTENT_TYPE, 6243 6243 - ); 6244 6244 - Ok(response) 6245 6245 - }), 7184 7184 + _ => { 7185 7185 + Box::pin(async move { 7186 7186 + let mut response = http::Response::new(empty_body()); 7187 7187 + let headers = response.headers_mut(); 7188 7188 + headers 7189 7189 + .insert( 7190 7190 + tonic::Status::GRPC_STATUS, 7191 7191 + (tonic::Code::Unimplemented as i32).into(), 7192 7192 + ); 7193 7193 + headers 7194 7194 + .insert( 7195 7195 + http::header::CONTENT_TYPE, 7196 7196 + tonic::metadata::GRPC_CONTENT_TYPE, 7197 7197 + ); 7198 7198 + Ok(response) 7199 7199 + }) 7200 7200 + } 6246 7201 } 6247 7202 } 6248 7203 } ··· 6400 7355 dead_code, 6401 7356 missing_docs, 6402 7357 clippy::wildcard_imports, 6403 6403 - clippy::let_unit_value 7358 7358 + clippy::let_unit_value, 6404 7359 )] 6405 6405 - use tonic::codegen::http::Uri; 6406 7360 use tonic::codegen::*; 7361 7361 + use tonic::codegen::http::Uri; 6407 7362 #[derive(Debug, Clone)] 6408 7363 pub struct SoundServiceClient<T> { 6409 7364 inner: tonic::client::Grpc<T>, ··· 6447 7402 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 6448 7403 >, 6449 7404 >, 6450 6450 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 6451 6451 - Into<StdError> + std::marker::Send + std::marker::Sync, 7405 7405 + <T as tonic::codegen::Service< 7406 7406 + http::Request<tonic::body::BoxBody>, 7407 7407 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6452 7408 { 6453 7409 SoundServiceClient::new(InterceptedService::new(inner, interceptor)) 6454 7410 } ··· 6486 7442 pub async fn adjust_volume( 6487 7443 &mut self, 6488 7444 request: impl tonic::IntoRequest<super::AdjustVolumeRequest>, 6489 6489 - ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status> 6490 6490 - { 6491 6491 - self.inner.ready().await.map_err(|e| { 6492 6492 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6493 6493 - })?; 7445 7445 + ) -> std::result::Result< 7446 7446 + tonic::Response<super::AdjustVolumeResponse>, 7447 7447 + tonic::Status, 7448 7448 + > { 7449 7449 + self.inner 7450 7450 + .ready() 7451 7451 + .await 7452 7452 + .map_err(|e| { 7453 7453 + tonic::Status::unknown( 7454 7454 + format!("Service was not ready: {}", e.into()), 7455 7455 + ) 7456 7456 + })?; 6494 7457 let codec = tonic::codec::ProstCodec::default(); 6495 6495 - let path = 6496 6496 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/AdjustVolume"); 7458 7458 + let path = http::uri::PathAndQuery::from_static( 7459 7459 + "/rockbox.v1alpha1.SoundService/AdjustVolume", 7460 7460 + ); 6497 7461 let mut req = request.into_request(); 6498 6498 - req.extensions_mut().insert(GrpcMethod::new( 6499 6499 - "rockbox.v1alpha1.SoundService", 6500 6500 - "AdjustVolume", 6501 6501 - )); 7462 7462 + req.extensions_mut() 7463 7463 + .insert( 7464 7464 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "AdjustVolume"), 7465 7465 + ); 6502 7466 self.inner.unary(req, path, codec).await 6503 7467 } 6504 7468 pub async fn sound_set( 6505 7469 &mut self, 6506 7470 request: impl tonic::IntoRequest<super::SoundSetRequest>, 6507 6507 - ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status> { 6508 6508 - self.inner.ready().await.map_err(|e| { 6509 6509 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6510 6510 - })?; 7471 7471 + ) -> std::result::Result< 7472 7472 + tonic::Response<super::SoundSetResponse>, 7473 7473 + tonic::Status, 7474 7474 + > { 7475 7475 + self.inner 7476 7476 + .ready() 7477 7477 + .await 7478 7478 + .map_err(|e| { 7479 7479 + tonic::Status::unknown( 7480 7480 + format!("Service was not ready: {}", e.into()), 7481 7481 + ) 7482 7482 + })?; 6511 7483 let codec = tonic::codec::ProstCodec::default(); 6512 6512 - let path = 6513 6513 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundSet"); 7484 7484 + let path = http::uri::PathAndQuery::from_static( 7485 7485 + "/rockbox.v1alpha1.SoundService/SoundSet", 7486 7486 + ); 6514 7487 let mut req = request.into_request(); 6515 7488 req.extensions_mut() 6516 7489 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundSet")); ··· 6519 7492 pub async fn sound_current( 6520 7493 &mut self, 6521 7494 request: impl tonic::IntoRequest<super::SoundCurrentRequest>, 6522 6522 - ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status> 6523 6523 - { 6524 6524 - self.inner.ready().await.map_err(|e| { 6525 6525 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6526 6526 - })?; 7495 7495 + ) -> std::result::Result< 7496 7496 + tonic::Response<super::SoundCurrentResponse>, 7497 7497 + tonic::Status, 7498 7498 + > { 7499 7499 + self.inner 7500 7500 + .ready() 7501 7501 + .await 7502 7502 + .map_err(|e| { 7503 7503 + tonic::Status::unknown( 7504 7504 + format!("Service was not ready: {}", e.into()), 7505 7505 + ) 7506 7506 + })?; 6527 7507 let codec = tonic::codec::ProstCodec::default(); 6528 6528 - let path = 6529 6529 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundCurrent"); 7508 7508 + let path = http::uri::PathAndQuery::from_static( 7509 7509 + "/rockbox.v1alpha1.SoundService/SoundCurrent", 7510 7510 + ); 6530 7511 let mut req = request.into_request(); 6531 6531 - req.extensions_mut().insert(GrpcMethod::new( 6532 6532 - "rockbox.v1alpha1.SoundService", 6533 6533 - "SoundCurrent", 6534 6534 - )); 7512 7512 + req.extensions_mut() 7513 7513 + .insert( 7514 7514 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundCurrent"), 7515 7515 + ); 6535 7516 self.inner.unary(req, path, codec).await 6536 7517 } 6537 7518 pub async fn sound_default( 6538 7519 &mut self, 6539 7520 request: impl tonic::IntoRequest<super::SoundDefaultRequest>, 6540 6540 - ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status> 6541 6541 - { 6542 6542 - self.inner.ready().await.map_err(|e| { 6543 6543 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6544 6544 - })?; 7521 7521 + ) -> std::result::Result< 7522 7522 + tonic::Response<super::SoundDefaultResponse>, 7523 7523 + tonic::Status, 7524 7524 + > { 7525 7525 + self.inner 7526 7526 + .ready() 7527 7527 + .await 7528 7528 + .map_err(|e| { 7529 7529 + tonic::Status::unknown( 7530 7530 + format!("Service was not ready: {}", e.into()), 7531 7531 + ) 7532 7532 + })?; 6545 7533 let codec = tonic::codec::ProstCodec::default(); 6546 6546 - let path = 6547 6547 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundDefault"); 7534 7534 + let path = http::uri::PathAndQuery::from_static( 7535 7535 + "/rockbox.v1alpha1.SoundService/SoundDefault", 7536 7536 + ); 6548 7537 let mut req = request.into_request(); 6549 6549 - req.extensions_mut().insert(GrpcMethod::new( 6550 6550 - "rockbox.v1alpha1.SoundService", 6551 6551 - "SoundDefault", 6552 6552 - )); 7538 7538 + req.extensions_mut() 7539 7539 + .insert( 7540 7540 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundDefault"), 7541 7541 + ); 6553 7542 self.inner.unary(req, path, codec).await 6554 7543 } 6555 7544 pub async fn sound_min( 6556 7545 &mut self, 6557 7546 request: impl tonic::IntoRequest<super::SoundMinRequest>, 6558 6558 - ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status> { 6559 6559 - self.inner.ready().await.map_err(|e| { 6560 6560 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6561 6561 - })?; 7547 7547 + ) -> std::result::Result< 7548 7548 + tonic::Response<super::SoundMinResponse>, 7549 7549 + tonic::Status, 7550 7550 + > { 7551 7551 + self.inner 7552 7552 + .ready() 7553 7553 + .await 7554 7554 + .map_err(|e| { 7555 7555 + tonic::Status::unknown( 7556 7556 + format!("Service was not ready: {}", e.into()), 7557 7557 + ) 7558 7558 + })?; 6562 7559 let codec = tonic::codec::ProstCodec::default(); 6563 6563 - let path = 6564 6564 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMin"); 7560 7560 + let path = http::uri::PathAndQuery::from_static( 7561 7561 + "/rockbox.v1alpha1.SoundService/SoundMin", 7562 7562 + ); 6565 7563 let mut req = request.into_request(); 6566 7564 req.extensions_mut() 6567 7565 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMin")); ··· 6570 7568 pub async fn sound_max( 6571 7569 &mut self, 6572 7570 request: impl tonic::IntoRequest<super::SoundMaxRequest>, 6573 6573 - ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status> { 6574 6574 - self.inner.ready().await.map_err(|e| { 6575 6575 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6576 6576 - })?; 7571 7571 + ) -> std::result::Result< 7572 7572 + tonic::Response<super::SoundMaxResponse>, 7573 7573 + tonic::Status, 7574 7574 + > { 7575 7575 + self.inner 7576 7576 + .ready() 7577 7577 + .await 7578 7578 + .map_err(|e| { 7579 7579 + tonic::Status::unknown( 7580 7580 + format!("Service was not ready: {}", e.into()), 7581 7581 + ) 7582 7582 + })?; 6577 7583 let codec = tonic::codec::ProstCodec::default(); 6578 6578 - let path = 6579 6579 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMax"); 7584 7584 + let path = http::uri::PathAndQuery::from_static( 7585 7585 + "/rockbox.v1alpha1.SoundService/SoundMax", 7586 7586 + ); 6580 7587 let mut req = request.into_request(); 6581 7588 req.extensions_mut() 6582 7589 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMax")); ··· 6585 7592 pub async fn sound_unit( 6586 7593 &mut self, 6587 7594 request: impl tonic::IntoRequest<super::SoundUnitRequest>, 6588 6588 - ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status> { 6589 6589 - self.inner.ready().await.map_err(|e| { 6590 6590 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6591 6591 - })?; 7595 7595 + ) -> std::result::Result< 7596 7596 + tonic::Response<super::SoundUnitResponse>, 7597 7597 + tonic::Status, 7598 7598 + > { 7599 7599 + self.inner 7600 7600 + .ready() 7601 7601 + .await 7602 7602 + .map_err(|e| { 7603 7603 + tonic::Status::unknown( 7604 7604 + format!("Service was not ready: {}", e.into()), 7605 7605 + ) 7606 7606 + })?; 6592 7607 let codec = tonic::codec::ProstCodec::default(); 6593 6593 - let path = 6594 6594 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundUnit"); 7608 7608 + let path = http::uri::PathAndQuery::from_static( 7609 7609 + "/rockbox.v1alpha1.SoundService/SoundUnit", 7610 7610 + ); 6595 7611 let mut req = request.into_request(); 6596 6596 - req.extensions_mut().insert(GrpcMethod::new( 6597 6597 - "rockbox.v1alpha1.SoundService", 6598 6598 - "SoundUnit", 6599 6599 - )); 7612 7612 + req.extensions_mut() 7613 7613 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundUnit")); 6600 7614 self.inner.unary(req, path, codec).await 6601 7615 } 6602 7616 pub async fn sound_val2_phys( 6603 7617 &mut self, 6604 7618 request: impl tonic::IntoRequest<super::SoundVal2PhysRequest>, 6605 6605 - ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status> 6606 6606 - { 6607 6607 - self.inner.ready().await.map_err(|e| { 6608 6608 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6609 6609 - })?; 7619 7619 + ) -> std::result::Result< 7620 7620 + tonic::Response<super::SoundVal2PhysResponse>, 7621 7621 + tonic::Status, 7622 7622 + > { 7623 7623 + self.inner 7624 7624 + .ready() 7625 7625 + .await 7626 7626 + .map_err(|e| { 7627 7627 + tonic::Status::unknown( 7628 7628 + format!("Service was not ready: {}", e.into()), 7629 7629 + ) 7630 7630 + })?; 6610 7631 let codec = tonic::codec::ProstCodec::default(); 6611 7632 let path = http::uri::PathAndQuery::from_static( 6612 7633 "/rockbox.v1alpha1.SoundService/SoundVal2Phys", 6613 7634 ); 6614 7635 let mut req = request.into_request(); 6615 6615 - req.extensions_mut().insert(GrpcMethod::new( 6616 6616 - "rockbox.v1alpha1.SoundService", 6617 6617 - "SoundVal2Phys", 6618 6618 - )); 7636 7636 + req.extensions_mut() 7637 7637 + .insert( 7638 7638 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundVal2Phys"), 7639 7639 + ); 6619 7640 self.inner.unary(req, path, codec).await 6620 7641 } 6621 7642 pub async fn get_pitch( 6622 7643 &mut self, 6623 7644 request: impl tonic::IntoRequest<super::GetPitchRequest>, 6624 6624 - ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status> { 6625 6625 - self.inner.ready().await.map_err(|e| { 6626 6626 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6627 6627 - })?; 7645 7645 + ) -> std::result::Result< 7646 7646 + tonic::Response<super::GetPitchResponse>, 7647 7647 + tonic::Status, 7648 7648 + > { 7649 7649 + self.inner 7650 7650 + .ready() 7651 7651 + .await 7652 7652 + .map_err(|e| { 7653 7653 + tonic::Status::unknown( 7654 7654 + format!("Service was not ready: {}", e.into()), 7655 7655 + ) 7656 7656 + })?; 6628 7657 let codec = tonic::codec::ProstCodec::default(); 6629 6629 - let path = 6630 6630 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/GetPitch"); 7658 7658 + let path = http::uri::PathAndQuery::from_static( 7659 7659 + "/rockbox.v1alpha1.SoundService/GetPitch", 7660 7660 + ); 6631 7661 let mut req = request.into_request(); 6632 7662 req.extensions_mut() 6633 7663 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "GetPitch")); ··· 6636 7666 pub async fn set_pitch( 6637 7667 &mut self, 6638 7668 request: impl tonic::IntoRequest<super::SetPitchRequest>, 6639 6639 - ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status> { 6640 6640 - self.inner.ready().await.map_err(|e| { 6641 6641 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6642 6642 - })?; 7669 7669 + ) -> std::result::Result< 7670 7670 + tonic::Response<super::SetPitchResponse>, 7671 7671 + tonic::Status, 7672 7672 + > { 7673 7673 + self.inner 7674 7674 + .ready() 7675 7675 + .await 7676 7676 + .map_err(|e| { 7677 7677 + tonic::Status::unknown( 7678 7678 + format!("Service was not ready: {}", e.into()), 7679 7679 + ) 7680 7680 + })?; 6643 7681 let codec = tonic::codec::ProstCodec::default(); 6644 6644 - let path = 6645 6645 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SetPitch"); 7682 7682 + let path = http::uri::PathAndQuery::from_static( 7683 7683 + "/rockbox.v1alpha1.SoundService/SetPitch", 7684 7684 + ); 6646 7685 let mut req = request.into_request(); 6647 7686 req.extensions_mut() 6648 7687 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SetPitch")); ··· 6651 7690 pub async fn beep_play( 6652 7691 &mut self, 6653 7692 request: impl tonic::IntoRequest<super::BeepPlayRequest>, 6654 6654 - ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status> { 6655 6655 - self.inner.ready().await.map_err(|e| { 6656 6656 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6657 6657 - })?; 7693 7693 + ) -> std::result::Result< 7694 7694 + tonic::Response<super::BeepPlayResponse>, 7695 7695 + tonic::Status, 7696 7696 + > { 7697 7697 + self.inner 7698 7698 + .ready() 7699 7699 + .await 7700 7700 + .map_err(|e| { 7701 7701 + tonic::Status::unknown( 7702 7702 + format!("Service was not ready: {}", e.into()), 7703 7703 + ) 7704 7704 + })?; 6658 7705 let codec = tonic::codec::ProstCodec::default(); 6659 6659 - let path = 6660 6660 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/BeepPlay"); 7706 7706 + let path = http::uri::PathAndQuery::from_static( 7707 7707 + "/rockbox.v1alpha1.SoundService/BeepPlay", 7708 7708 + ); 6661 7709 let mut req = request.into_request(); 6662 7710 req.extensions_mut() 6663 7711 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "BeepPlay")); ··· 6666 7714 pub async fn pcmbuf_fade( 6667 7715 &mut self, 6668 7716 request: impl tonic::IntoRequest<super::PcmbufFadeRequest>, 6669 6669 - ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status> 6670 6670 - { 6671 6671 - self.inner.ready().await.map_err(|e| { 6672 6672 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6673 6673 - })?; 7717 7717 + ) -> std::result::Result< 7718 7718 + tonic::Response<super::PcmbufFadeResponse>, 7719 7719 + tonic::Status, 7720 7720 + > { 7721 7721 + self.inner 7722 7722 + .ready() 7723 7723 + .await 7724 7724 + .map_err(|e| { 7725 7725 + tonic::Status::unknown( 7726 7726 + format!("Service was not ready: {}", e.into()), 7727 7727 + ) 7728 7728 + })?; 6674 7729 let codec = tonic::codec::ProstCodec::default(); 6675 6675 - let path = 6676 6676 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/PcmbufFade"); 7730 7730 + let path = http::uri::PathAndQuery::from_static( 7731 7731 + "/rockbox.v1alpha1.SoundService/PcmbufFade", 7732 7732 + ); 6677 7733 let mut req = request.into_request(); 6678 6678 - req.extensions_mut().insert(GrpcMethod::new( 6679 6679 - "rockbox.v1alpha1.SoundService", 6680 6680 - "PcmbufFade", 6681 6681 - )); 7734 7734 + req.extensions_mut() 7735 7735 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "PcmbufFade")); 6682 7736 self.inner.unary(req, path, codec).await 6683 7737 } 6684 7738 pub async fn pcmbuf_set_low_latency( 6685 7739 &mut self, 6686 7740 request: impl tonic::IntoRequest<super::PcmbufSetLowLatencyRequest>, 6687 6687 - ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status> 6688 6688 - { 6689 6689 - self.inner.ready().await.map_err(|e| { 6690 6690 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6691 6691 - })?; 7741 7741 + ) -> std::result::Result< 7742 7742 + tonic::Response<super::PcmbufSetLowLatencyResponse>, 7743 7743 + tonic::Status, 7744 7744 + > { 7745 7745 + self.inner 7746 7746 + .ready() 7747 7747 + .await 7748 7748 + .map_err(|e| { 7749 7749 + tonic::Status::unknown( 7750 7750 + format!("Service was not ready: {}", e.into()), 7751 7751 + ) 7752 7752 + })?; 6692 7753 let codec = tonic::codec::ProstCodec::default(); 6693 7754 let path = http::uri::PathAndQuery::from_static( 6694 7755 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency", 6695 7756 ); 6696 7757 let mut req = request.into_request(); 6697 6697 - req.extensions_mut().insert(GrpcMethod::new( 6698 6698 - "rockbox.v1alpha1.SoundService", 6699 6699 - "PcmbufSetLowLatency", 6700 6700 - )); 7758 7758 + req.extensions_mut() 7759 7759 + .insert( 7760 7760 + GrpcMethod::new( 7761 7761 + "rockbox.v1alpha1.SoundService", 7762 7762 + "PcmbufSetLowLatency", 7763 7763 + ), 7764 7764 + ); 6701 7765 self.inner.unary(req, path, codec).await 6702 7766 } 6703 7767 pub async fn system_sound_play( 6704 7768 &mut self, 6705 7769 request: impl tonic::IntoRequest<super::SystemSoundPlayRequest>, 6706 6706 - ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status> 6707 6707 - { 6708 6708 - self.inner.ready().await.map_err(|e| { 6709 6709 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6710 6710 - })?; 7770 7770 + ) -> std::result::Result< 7771 7771 + tonic::Response<super::SystemSoundPlayResponse>, 7772 7772 + tonic::Status, 7773 7773 + > { 7774 7774 + self.inner 7775 7775 + .ready() 7776 7776 + .await 7777 7777 + .map_err(|e| { 7778 7778 + tonic::Status::unknown( 7779 7779 + format!("Service was not ready: {}", e.into()), 7780 7780 + ) 7781 7781 + })?; 6711 7782 let codec = tonic::codec::ProstCodec::default(); 6712 7783 let path = http::uri::PathAndQuery::from_static( 6713 7784 "/rockbox.v1alpha1.SoundService/SystemSoundPlay", 6714 7785 ); 6715 7786 let mut req = request.into_request(); 6716 6716 - req.extensions_mut().insert(GrpcMethod::new( 6717 6717 - "rockbox.v1alpha1.SoundService", 6718 6718 - "SystemSoundPlay", 6719 6719 - )); 7787 7787 + req.extensions_mut() 7788 7788 + .insert( 7789 7789 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SystemSoundPlay"), 7790 7790 + ); 6720 7791 self.inner.unary(req, path, codec).await 6721 7792 } 6722 7793 pub async fn keyclick_click( 6723 7794 &mut self, 6724 7795 request: impl tonic::IntoRequest<super::KeyclickClickRequest>, 6725 6725 - ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status> 6726 6726 - { 6727 6727 - self.inner.ready().await.map_err(|e| { 6728 6728 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6729 6729 - })?; 7796 7796 + ) -> std::result::Result< 7797 7797 + tonic::Response<super::KeyclickClickResponse>, 7798 7798 + tonic::Status, 7799 7799 + > { 7800 7800 + self.inner 7801 7801 + .ready() 7802 7802 + .await 7803 7803 + .map_err(|e| { 7804 7804 + tonic::Status::unknown( 7805 7805 + format!("Service was not ready: {}", e.into()), 7806 7806 + ) 7807 7807 + })?; 6730 7808 let codec = tonic::codec::ProstCodec::default(); 6731 7809 let path = http::uri::PathAndQuery::from_static( 6732 7810 "/rockbox.v1alpha1.SoundService/KeyclickClick", 6733 7811 ); 6734 7812 let mut req = request.into_request(); 6735 6735 - req.extensions_mut().insert(GrpcMethod::new( 6736 6736 - "rockbox.v1alpha1.SoundService", 6737 6737 - "KeyclickClick", 6738 6738 - )); 7813 7813 + req.extensions_mut() 7814 7814 + .insert( 7815 7815 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "KeyclickClick"), 7816 7816 + ); 6739 7817 self.inner.unary(req, path, codec).await 6740 7818 } 6741 7819 } ··· 6747 7825 dead_code, 6748 7826 missing_docs, 6749 7827 clippy::wildcard_imports, 6750 6750 - clippy::let_unit_value 7828 7828 + clippy::let_unit_value, 6751 7829 )] 6752 7830 use tonic::codegen::*; 6753 7831 /// Generated trait containing gRPC methods that should be implemented for use with SoundServiceServer. ··· 6756 7834 async fn adjust_volume( 6757 7835 &self, 6758 7836 request: tonic::Request<super::AdjustVolumeRequest>, 6759 6759 - ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status>; 7837 7837 + ) -> std::result::Result< 7838 7838 + tonic::Response<super::AdjustVolumeResponse>, 7839 7839 + tonic::Status, 7840 7840 + >; 6760 7841 async fn sound_set( 6761 7842 &self, 6762 7843 request: tonic::Request<super::SoundSetRequest>, 6763 6763 - ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status>; 7844 7844 + ) -> std::result::Result< 7845 7845 + tonic::Response<super::SoundSetResponse>, 7846 7846 + tonic::Status, 7847 7847 + >; 6764 7848 async fn sound_current( 6765 7849 &self, 6766 7850 request: tonic::Request<super::SoundCurrentRequest>, 6767 6767 - ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status>; 7851 7851 + ) -> std::result::Result< 7852 7852 + tonic::Response<super::SoundCurrentResponse>, 7853 7853 + tonic::Status, 7854 7854 + >; 6768 7855 async fn sound_default( 6769 7856 &self, 6770 7857 request: tonic::Request<super::SoundDefaultRequest>, 6771 6771 - ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status>; 7858 7858 + ) -> std::result::Result< 7859 7859 + tonic::Response<super::SoundDefaultResponse>, 7860 7860 + tonic::Status, 7861 7861 + >; 6772 7862 async fn sound_min( 6773 7863 &self, 6774 7864 request: tonic::Request<super::SoundMinRequest>, 6775 6775 - ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status>; 7865 7865 + ) -> std::result::Result< 7866 7866 + tonic::Response<super::SoundMinResponse>, 7867 7867 + tonic::Status, 7868 7868 + >; 6776 7869 async fn sound_max( 6777 7870 &self, 6778 7871 request: tonic::Request<super::SoundMaxRequest>, 6779 6779 - ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status>; 7872 7872 + ) -> std::result::Result< 7873 7873 + tonic::Response<super::SoundMaxResponse>, 7874 7874 + tonic::Status, 7875 7875 + >; 6780 7876 async fn sound_unit( 6781 7877 &self, 6782 7878 request: tonic::Request<super::SoundUnitRequest>, 6783 6783 - ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status>; 7879 7879 + ) -> std::result::Result< 7880 7880 + tonic::Response<super::SoundUnitResponse>, 7881 7881 + tonic::Status, 7882 7882 + >; 6784 7883 async fn sound_val2_phys( 6785 7884 &self, 6786 7885 request: tonic::Request<super::SoundVal2PhysRequest>, 6787 6787 - ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status>; 7886 7886 + ) -> std::result::Result< 7887 7887 + tonic::Response<super::SoundVal2PhysResponse>, 7888 7888 + tonic::Status, 7889 7889 + >; 6788 7890 async fn get_pitch( 6789 7891 &self, 6790 7892 request: tonic::Request<super::GetPitchRequest>, 6791 6791 - ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status>; 7893 7893 + ) -> std::result::Result< 7894 7894 + tonic::Response<super::GetPitchResponse>, 7895 7895 + tonic::Status, 7896 7896 + >; 6792 7897 async fn set_pitch( 6793 7898 &self, 6794 7899 request: tonic::Request<super::SetPitchRequest>, 6795 6795 - ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status>; 7900 7900 + ) -> std::result::Result< 7901 7901 + tonic::Response<super::SetPitchResponse>, 7902 7902 + tonic::Status, 7903 7903 + >; 6796 7904 async fn beep_play( 6797 7905 &self, 6798 7906 request: tonic::Request<super::BeepPlayRequest>, 6799 6799 - ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status>; 7907 7907 + ) -> std::result::Result< 7908 7908 + tonic::Response<super::BeepPlayResponse>, 7909 7909 + tonic::Status, 7910 7910 + >; 6800 7911 async fn pcmbuf_fade( 6801 7912 &self, 6802 7913 request: tonic::Request<super::PcmbufFadeRequest>, 6803 6803 - ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status>; 7914 7914 + ) -> std::result::Result< 7915 7915 + tonic::Response<super::PcmbufFadeResponse>, 7916 7916 + tonic::Status, 7917 7917 + >; 6804 7918 async fn pcmbuf_set_low_latency( 6805 7919 &self, 6806 7920 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 6807 6807 - ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status>; 7921 7921 + ) -> std::result::Result< 7922 7922 + tonic::Response<super::PcmbufSetLowLatencyResponse>, 7923 7923 + tonic::Status, 7924 7924 + >; 6808 7925 async fn system_sound_play( 6809 7926 &self, 6810 7927 request: tonic::Request<super::SystemSoundPlayRequest>, 6811 6811 - ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status>; 7928 7928 + ) -> std::result::Result< 7929 7929 + tonic::Response<super::SystemSoundPlayResponse>, 7930 7930 + tonic::Status, 7931 7931 + >; 6812 7932 async fn keyclick_click( 6813 7933 &self, 6814 7934 request: tonic::Request<super::KeyclickClickRequest>, 6815 6815 - ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>; 7935 7935 + ) -> std::result::Result< 7936 7936 + tonic::Response<super::KeyclickClickResponse>, 7937 7937 + tonic::Status, 7938 7938 + >; 6816 7939 } 6817 7940 #[derive(Debug)] 6818 7941 pub struct SoundServiceServer<T> { ··· 6835 7958 max_encoding_message_size: None, 6836 7959 } 6837 7960 } 6838 6838 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 7961 7961 + pub fn with_interceptor<F>( 7962 7962 + inner: T, 7963 7963 + interceptor: F, 7964 7964 + ) -> InterceptedService<Self, F> 6839 7965 where 6840 7966 F: tonic::service::Interceptor, 6841 7967 { ··· 6890 8016 "/rockbox.v1alpha1.SoundService/AdjustVolume" => { 6891 8017 #[allow(non_camel_case_types)] 6892 8018 struct AdjustVolumeSvc<T: SoundService>(pub Arc<T>); 6893 6893 - impl<T: SoundService> tonic::server::UnaryService<super::AdjustVolumeRequest> 6894 6894 - for AdjustVolumeSvc<T> 6895 6895 - { 8019 8019 + impl< 8020 8020 + T: SoundService, 8021 8021 + > tonic::server::UnaryService<super::AdjustVolumeRequest> 8022 8022 + for AdjustVolumeSvc<T> { 6896 8023 type Response = super::AdjustVolumeResponse; 6897 6897 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8024 8024 + type Future = BoxFuture< 8025 8025 + tonic::Response<Self::Response>, 8026 8026 + tonic::Status, 8027 8027 + >; 6898 8028 fn call( 6899 8029 &mut self, 6900 8030 request: tonic::Request<super::AdjustVolumeRequest>, ··· 6931 8061 "/rockbox.v1alpha1.SoundService/SoundSet" => { 6932 8062 #[allow(non_camel_case_types)] 6933 8063 struct SoundSetSvc<T: SoundService>(pub Arc<T>); 6934 6934 - impl<T: SoundService> tonic::server::UnaryService<super::SoundSetRequest> for SoundSetSvc<T> { 8064 8064 + impl< 8065 8065 + T: SoundService, 8066 8066 + > tonic::server::UnaryService<super::SoundSetRequest> 8067 8067 + for SoundSetSvc<T> { 6935 8068 type Response = super::SoundSetResponse; 6936 6936 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8069 8069 + type Future = BoxFuture< 8070 8070 + tonic::Response<Self::Response>, 8071 8071 + tonic::Status, 8072 8072 + >; 6937 8073 fn call( 6938 8074 &mut self, 6939 8075 request: tonic::Request<super::SoundSetRequest>, ··· 6970 8106 "/rockbox.v1alpha1.SoundService/SoundCurrent" => { 6971 8107 #[allow(non_camel_case_types)] 6972 8108 struct SoundCurrentSvc<T: SoundService>(pub Arc<T>); 6973 6973 - impl<T: SoundService> tonic::server::UnaryService<super::SoundCurrentRequest> 6974 6974 - for SoundCurrentSvc<T> 6975 6975 - { 8109 8109 + impl< 8110 8110 + T: SoundService, 8111 8111 + > tonic::server::UnaryService<super::SoundCurrentRequest> 8112 8112 + for SoundCurrentSvc<T> { 6976 8113 type Response = super::SoundCurrentResponse; 6977 6977 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8114 8114 + type Future = BoxFuture< 8115 8115 + tonic::Response<Self::Response>, 8116 8116 + tonic::Status, 8117 8117 + >; 6978 8118 fn call( 6979 8119 &mut self, 6980 8120 request: tonic::Request<super::SoundCurrentRequest>, ··· 7011 8151 "/rockbox.v1alpha1.SoundService/SoundDefault" => { 7012 8152 #[allow(non_camel_case_types)] 7013 8153 struct SoundDefaultSvc<T: SoundService>(pub Arc<T>); 7014 7014 - impl<T: SoundService> tonic::server::UnaryService<super::SoundDefaultRequest> 7015 7015 - for SoundDefaultSvc<T> 7016 7016 - { 8154 8154 + impl< 8155 8155 + T: SoundService, 8156 8156 + > tonic::server::UnaryService<super::SoundDefaultRequest> 8157 8157 + for SoundDefaultSvc<T> { 7017 8158 type Response = super::SoundDefaultResponse; 7018 7018 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8159 8159 + type Future = BoxFuture< 8160 8160 + tonic::Response<Self::Response>, 8161 8161 + tonic::Status, 8162 8162 + >; 7019 8163 fn call( 7020 8164 &mut self, 7021 8165 request: tonic::Request<super::SoundDefaultRequest>, ··· 7052 8196 "/rockbox.v1alpha1.SoundService/SoundMin" => { 7053 8197 #[allow(non_camel_case_types)] 7054 8198 struct SoundMinSvc<T: SoundService>(pub Arc<T>); 7055 7055 - impl<T: SoundService> tonic::server::UnaryService<super::SoundMinRequest> for SoundMinSvc<T> { 8199 8199 + impl< 8200 8200 + T: SoundService, 8201 8201 + > tonic::server::UnaryService<super::SoundMinRequest> 8202 8202 + for SoundMinSvc<T> { 7056 8203 type Response = super::SoundMinResponse; 7057 7057 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8204 8204 + type Future = BoxFuture< 8205 8205 + tonic::Response<Self::Response>, 8206 8206 + tonic::Status, 8207 8207 + >; 7058 8208 fn call( 7059 8209 &mut self, 7060 8210 request: tonic::Request<super::SoundMinRequest>, ··· 7091 8241 "/rockbox.v1alpha1.SoundService/SoundMax" => { 7092 8242 #[allow(non_camel_case_types)] 7093 8243 struct SoundMaxSvc<T: SoundService>(pub Arc<T>); 7094 7094 - impl<T: SoundService> tonic::server::UnaryService<super::SoundMaxRequest> for SoundMaxSvc<T> { 8244 8244 + impl< 8245 8245 + T: SoundService, 8246 8246 + > tonic::server::UnaryService<super::SoundMaxRequest> 8247 8247 + for SoundMaxSvc<T> { 7095 8248 type Response = super::SoundMaxResponse; 7096 7096 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8249 8249 + type Future = BoxFuture< 8250 8250 + tonic::Response<Self::Response>, 8251 8251 + tonic::Status, 8252 8252 + >; 7097 8253 fn call( 7098 8254 &mut self, 7099 8255 request: tonic::Request<super::SoundMaxRequest>, ··· 7130 8286 "/rockbox.v1alpha1.SoundService/SoundUnit" => { 7131 8287 #[allow(non_camel_case_types)] 7132 8288 struct SoundUnitSvc<T: SoundService>(pub Arc<T>); 7133 7133 - impl<T: SoundService> tonic::server::UnaryService<super::SoundUnitRequest> for SoundUnitSvc<T> { 8289 8289 + impl< 8290 8290 + T: SoundService, 8291 8291 + > tonic::server::UnaryService<super::SoundUnitRequest> 8292 8292 + for SoundUnitSvc<T> { 7134 8293 type Response = super::SoundUnitResponse; 7135 7135 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8294 8294 + type Future = BoxFuture< 8295 8295 + tonic::Response<Self::Response>, 8296 8296 + tonic::Status, 8297 8297 + >; 7136 8298 fn call( 7137 8299 &mut self, 7138 8300 request: tonic::Request<super::SoundUnitRequest>, ··· 7169 8331 "/rockbox.v1alpha1.SoundService/SoundVal2Phys" => { 7170 8332 #[allow(non_camel_case_types)] 7171 8333 struct SoundVal2PhysSvc<T: SoundService>(pub Arc<T>); 7172 7172 - impl<T: SoundService> tonic::server::UnaryService<super::SoundVal2PhysRequest> 7173 7173 - for SoundVal2PhysSvc<T> 7174 7174 - { 8334 8334 + impl< 8335 8335 + T: SoundService, 8336 8336 + > tonic::server::UnaryService<super::SoundVal2PhysRequest> 8337 8337 + for SoundVal2PhysSvc<T> { 7175 8338 type Response = super::SoundVal2PhysResponse; 7176 7176 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8339 8339 + type Future = BoxFuture< 8340 8340 + tonic::Response<Self::Response>, 8341 8341 + tonic::Status, 8342 8342 + >; 7177 8343 fn call( 7178 8344 &mut self, 7179 8345 request: tonic::Request<super::SoundVal2PhysRequest>, ··· 7210 8376 "/rockbox.v1alpha1.SoundService/GetPitch" => { 7211 8377 #[allow(non_camel_case_types)] 7212 8378 struct GetPitchSvc<T: SoundService>(pub Arc<T>); 7213 7213 - impl<T: SoundService> tonic::server::UnaryService<super::GetPitchRequest> for GetPitchSvc<T> { 8379 8379 + impl< 8380 8380 + T: SoundService, 8381 8381 + > tonic::server::UnaryService<super::GetPitchRequest> 8382 8382 + for GetPitchSvc<T> { 7214 8383 type Response = super::GetPitchResponse; 7215 7215 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8384 8384 + type Future = BoxFuture< 8385 8385 + tonic::Response<Self::Response>, 8386 8386 + tonic::Status, 8387 8387 + >; 7216 8388 fn call( 7217 8389 &mut self, 7218 8390 request: tonic::Request<super::GetPitchRequest>, ··· 7249 8421 "/rockbox.v1alpha1.SoundService/SetPitch" => { 7250 8422 #[allow(non_camel_case_types)] 7251 8423 struct SetPitchSvc<T: SoundService>(pub Arc<T>); 7252 7252 - impl<T: SoundService> tonic::server::UnaryService<super::SetPitchRequest> for SetPitchSvc<T> { 8424 8424 + impl< 8425 8425 + T: SoundService, 8426 8426 + > tonic::server::UnaryService<super::SetPitchRequest> 8427 8427 + for SetPitchSvc<T> { 7253 8428 type Response = super::SetPitchResponse; 7254 7254 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8429 8429 + type Future = BoxFuture< 8430 8430 + tonic::Response<Self::Response>, 8431 8431 + tonic::Status, 8432 8432 + >; 7255 8433 fn call( 7256 8434 &mut self, 7257 8435 request: tonic::Request<super::SetPitchRequest>, ··· 7288 8466 "/rockbox.v1alpha1.SoundService/BeepPlay" => { 7289 8467 #[allow(non_camel_case_types)] 7290 8468 struct BeepPlaySvc<T: SoundService>(pub Arc<T>); 7291 7291 - impl<T: SoundService> tonic::server::UnaryService<super::BeepPlayRequest> for BeepPlaySvc<T> { 8469 8469 + impl< 8470 8470 + T: SoundService, 8471 8471 + > tonic::server::UnaryService<super::BeepPlayRequest> 8472 8472 + for BeepPlaySvc<T> { 7292 8473 type Response = super::BeepPlayResponse; 7293 7293 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8474 8474 + type Future = BoxFuture< 8475 8475 + tonic::Response<Self::Response>, 8476 8476 + tonic::Status, 8477 8477 + >; 7294 8478 fn call( 7295 8479 &mut self, 7296 8480 request: tonic::Request<super::BeepPlayRequest>, ··· 7327 8511 "/rockbox.v1alpha1.SoundService/PcmbufFade" => { 7328 8512 #[allow(non_camel_case_types)] 7329 8513 struct PcmbufFadeSvc<T: SoundService>(pub Arc<T>); 7330 7330 - impl<T: SoundService> tonic::server::UnaryService<super::PcmbufFadeRequest> for PcmbufFadeSvc<T> { 8514 8514 + impl< 8515 8515 + T: SoundService, 8516 8516 + > tonic::server::UnaryService<super::PcmbufFadeRequest> 8517 8517 + for PcmbufFadeSvc<T> { 7331 8518 type Response = super::PcmbufFadeResponse; 7332 7332 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8519 8519 + type Future = BoxFuture< 8520 8520 + tonic::Response<Self::Response>, 8521 8521 + tonic::Status, 8522 8522 + >; 7333 8523 fn call( 7334 8524 &mut self, 7335 8525 request: tonic::Request<super::PcmbufFadeRequest>, ··· 7366 8556 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency" => { 7367 8557 #[allow(non_camel_case_types)] 7368 8558 struct PcmbufSetLowLatencySvc<T: SoundService>(pub Arc<T>); 7369 7369 - impl<T: SoundService> 7370 7370 - tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 7371 7371 - for PcmbufSetLowLatencySvc<T> 7372 7372 - { 8559 8559 + impl< 8560 8560 + T: SoundService, 8561 8561 + > tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 8562 8562 + for PcmbufSetLowLatencySvc<T> { 7373 8563 type Response = super::PcmbufSetLowLatencyResponse; 7374 7374 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8564 8564 + type Future = BoxFuture< 8565 8565 + tonic::Response<Self::Response>, 8566 8566 + tonic::Status, 8567 8567 + >; 7375 8568 fn call( 7376 8569 &mut self, 7377 8570 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 7378 8571 ) -> Self::Future { 7379 8572 let inner = Arc::clone(&self.0); 7380 8573 let fut = async move { 7381 7381 - <T as SoundService>::pcmbuf_set_low_latency(&inner, request).await 8574 8574 + <T as SoundService>::pcmbuf_set_low_latency(&inner, request) 8575 8575 + .await 7382 8576 }; 7383 8577 Box::pin(fut) 7384 8578 } ··· 7408 8602 "/rockbox.v1alpha1.SoundService/SystemSoundPlay" => { 7409 8603 #[allow(non_camel_case_types)] 7410 8604 struct SystemSoundPlaySvc<T: SoundService>(pub Arc<T>); 7411 7411 - impl<T: SoundService> tonic::server::UnaryService<super::SystemSoundPlayRequest> 7412 7412 - for SystemSoundPlaySvc<T> 7413 7413 - { 8605 8605 + impl< 8606 8606 + T: SoundService, 8607 8607 + > tonic::server::UnaryService<super::SystemSoundPlayRequest> 8608 8608 + for SystemSoundPlaySvc<T> { 7414 8609 type Response = super::SystemSoundPlayResponse; 7415 7415 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8610 8610 + type Future = BoxFuture< 8611 8611 + tonic::Response<Self::Response>, 8612 8612 + tonic::Status, 8613 8613 + >; 7416 8614 fn call( 7417 8615 &mut self, 7418 8616 request: tonic::Request<super::SystemSoundPlayRequest>, 7419 8617 ) -> Self::Future { 7420 8618 let inner = Arc::clone(&self.0); 7421 8619 let fut = async move { 7422 7422 - <T as SoundService>::system_sound_play(&inner, request).await 8620 8620 + <T as SoundService>::system_sound_play(&inner, request) 8621 8621 + .await 7423 8622 }; 7424 8623 Box::pin(fut) 7425 8624 } ··· 7449 8648 "/rockbox.v1alpha1.SoundService/KeyclickClick" => { 7450 8649 #[allow(non_camel_case_types)] 7451 8650 struct KeyclickClickSvc<T: SoundService>(pub Arc<T>); 7452 7452 - impl<T: SoundService> tonic::server::UnaryService<super::KeyclickClickRequest> 7453 7453 - for KeyclickClickSvc<T> 7454 7454 - { 8651 8651 + impl< 8652 8652 + T: SoundService, 8653 8653 + > tonic::server::UnaryService<super::KeyclickClickRequest> 8654 8654 + for KeyclickClickSvc<T> { 7455 8655 type Response = super::KeyclickClickResponse; 7456 7456 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8656 8656 + type Future = BoxFuture< 8657 8657 + tonic::Response<Self::Response>, 8658 8658 + tonic::Status, 8659 8659 + >; 7457 8660 fn call( 7458 8661 &mut self, 7459 8662 request: tonic::Request<super::KeyclickClickRequest>, ··· 7487 8690 }; 7488 8691 Box::pin(fut) 7489 8692 } 7490 7490 - _ => Box::pin(async move { 7491 7491 - let mut response = http::Response::new(empty_body()); 7492 7492 - let headers = response.headers_mut(); 7493 7493 - headers.insert( 7494 7494 - tonic::Status::GRPC_STATUS, 7495 7495 - (tonic::Code::Unimplemented as i32).into(), 7496 7496 - ); 7497 7497 - headers.insert( 7498 7498 - http::header::CONTENT_TYPE, 7499 7499 - tonic::metadata::GRPC_CONTENT_TYPE, 7500 7500 - ); 7501 7501 - Ok(response) 7502 7502 - }), 8693 8693 + _ => { 8694 8694 + Box::pin(async move { 8695 8695 + let mut response = http::Response::new(empty_body()); 8696 8696 + let headers = response.headers_mut(); 8697 8697 + headers 8698 8698 + .insert( 8699 8699 + tonic::Status::GRPC_STATUS, 8700 8700 + (tonic::Code::Unimplemented as i32).into(), 8701 8701 + ); 8702 8702 + headers 8703 8703 + .insert( 8704 8704 + http::header::CONTENT_TYPE, 8705 8705 + tonic::metadata::GRPC_CONTENT_TYPE, 8706 8706 + ); 8707 8707 + Ok(response) 8708 8708 + }) 8709 8709 + } 7503 8710 } 7504 8711 } 7505 8712 } ··· 7560 8767 dead_code, 7561 8768 missing_docs, 7562 8769 clippy::wildcard_imports, 7563 7563 - clippy::let_unit_value 8770 8770 + clippy::let_unit_value, 7564 8771 )] 7565 7565 - use tonic::codegen::http::Uri; 7566 8772 use tonic::codegen::*; 8773 8773 + use tonic::codegen::http::Uri; 7567 8774 #[derive(Debug, Clone)] 7568 8775 pub struct SystemServiceClient<T> { 7569 8776 inner: tonic::client::Grpc<T>, ··· 7607 8814 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 7608 8815 >, 7609 8816 >, 7610 7610 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 7611 7611 - Into<StdError> + std::marker::Send + std::marker::Sync, 8817 8817 + <T as tonic::codegen::Service< 8818 8818 + http::Request<tonic::body::BoxBody>, 8819 8819 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 7612 8820 { 7613 8821 SystemServiceClient::new(InterceptedService::new(inner, interceptor)) 7614 8822 } ··· 7646 8854 pub async fn get_rockbox_version( 7647 8855 &mut self, 7648 8856 request: impl tonic::IntoRequest<super::GetRockboxVersionRequest>, 7649 7649 - ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status> 7650 7650 - { 7651 7651 - self.inner.ready().await.map_err(|e| { 7652 7652 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7653 7653 - })?; 8857 8857 + ) -> std::result::Result< 8858 8858 + tonic::Response<super::GetRockboxVersionResponse>, 8859 8859 + tonic::Status, 8860 8860 + > { 8861 8861 + self.inner 8862 8862 + .ready() 8863 8863 + .await 8864 8864 + .map_err(|e| { 8865 8865 + tonic::Status::unknown( 8866 8866 + format!("Service was not ready: {}", e.into()), 8867 8867 + ) 8868 8868 + })?; 7654 8869 let codec = tonic::codec::ProstCodec::default(); 7655 8870 let path = http::uri::PathAndQuery::from_static( 7656 8871 "/rockbox.v1alpha1.SystemService/GetRockboxVersion", 7657 8872 ); 7658 8873 let mut req = request.into_request(); 7659 7659 - req.extensions_mut().insert(GrpcMethod::new( 7660 7660 - "rockbox.v1alpha1.SystemService", 7661 7661 - "GetRockboxVersion", 7662 7662 - )); 8874 8874 + req.extensions_mut() 8875 8875 + .insert( 8876 8876 + GrpcMethod::new( 8877 8877 + "rockbox.v1alpha1.SystemService", 8878 8878 + "GetRockboxVersion", 8879 8879 + ), 8880 8880 + ); 7663 8881 self.inner.unary(req, path, codec).await 7664 8882 } 7665 8883 pub async fn get_global_status( 7666 8884 &mut self, 7667 8885 request: impl tonic::IntoRequest<super::GetGlobalStatusRequest>, 7668 7668 - ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status> 7669 7669 - { 7670 7670 - self.inner.ready().await.map_err(|e| { 7671 7671 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7672 7672 - })?; 8886 8886 + ) -> std::result::Result< 8887 8887 + tonic::Response<super::GetGlobalStatusResponse>, 8888 8888 + tonic::Status, 8889 8889 + > { 8890 8890 + self.inner 8891 8891 + .ready() 8892 8892 + .await 8893 8893 + .map_err(|e| { 8894 8894 + tonic::Status::unknown( 8895 8895 + format!("Service was not ready: {}", e.into()), 8896 8896 + ) 8897 8897 + })?; 7673 8898 let codec = tonic::codec::ProstCodec::default(); 7674 8899 let path = http::uri::PathAndQuery::from_static( 7675 8900 "/rockbox.v1alpha1.SystemService/GetGlobalStatus", 7676 8901 ); 7677 8902 let mut req = request.into_request(); 7678 7678 - req.extensions_mut().insert(GrpcMethod::new( 7679 7679 - "rockbox.v1alpha1.SystemService", 7680 7680 - "GetGlobalStatus", 7681 7681 - )); 8903 8903 + req.extensions_mut() 8904 8904 + .insert( 8905 8905 + GrpcMethod::new("rockbox.v1alpha1.SystemService", "GetGlobalStatus"), 8906 8906 + ); 7682 8907 self.inner.unary(req, path, codec).await 7683 8908 } 7684 8909 } ··· 7690 8915 dead_code, 7691 8916 missing_docs, 7692 8917 clippy::wildcard_imports, 7693 7693 - clippy::let_unit_value 8918 8918 + clippy::let_unit_value, 7694 8919 )] 7695 8920 use tonic::codegen::*; 7696 8921 /// Generated trait containing gRPC methods that should be implemented for use with SystemServiceServer. ··· 7699 8924 async fn get_rockbox_version( 7700 8925 &self, 7701 8926 request: tonic::Request<super::GetRockboxVersionRequest>, 7702 7702 - ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status>; 8927 8927 + ) -> std::result::Result< 8928 8928 + tonic::Response<super::GetRockboxVersionResponse>, 8929 8929 + tonic::Status, 8930 8930 + >; 7703 8931 async fn get_global_status( 7704 8932 &self, 7705 8933 request: tonic::Request<super::GetGlobalStatusRequest>, 7706 7706 - ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>; 8934 8934 + ) -> std::result::Result< 8935 8935 + tonic::Response<super::GetGlobalStatusResponse>, 8936 8936 + tonic::Status, 8937 8937 + >; 7707 8938 } 7708 8939 #[derive(Debug)] 7709 8940 pub struct SystemServiceServer<T> { ··· 7726 8957 max_encoding_message_size: None, 7727 8958 } 7728 8959 } 7729 7729 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 8960 8960 + pub fn with_interceptor<F>( 8961 8961 + inner: T, 8962 8962 + interceptor: F, 8963 8963 + ) -> InterceptedService<Self, F> 7730 8964 where 7731 8965 F: tonic::service::Interceptor, 7732 8966 { ··· 7781 9015 "/rockbox.v1alpha1.SystemService/GetRockboxVersion" => { 7782 9016 #[allow(non_camel_case_types)] 7783 9017 struct GetRockboxVersionSvc<T: SystemService>(pub Arc<T>); 7784 7784 - impl<T: SystemService> 7785 7785 - tonic::server::UnaryService<super::GetRockboxVersionRequest> 7786 7786 - for GetRockboxVersionSvc<T> 7787 7787 - { 9018 9018 + impl< 9019 9019 + T: SystemService, 9020 9020 + > tonic::server::UnaryService<super::GetRockboxVersionRequest> 9021 9021 + for GetRockboxVersionSvc<T> { 7788 9022 type Response = super::GetRockboxVersionResponse; 7789 7789 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9023 9023 + type Future = BoxFuture< 9024 9024 + tonic::Response<Self::Response>, 9025 9025 + tonic::Status, 9026 9026 + >; 7790 9027 fn call( 7791 9028 &mut self, 7792 9029 request: tonic::Request<super::GetRockboxVersionRequest>, 7793 9030 ) -> Self::Future { 7794 9031 let inner = Arc::clone(&self.0); 7795 9032 let fut = async move { 7796 7796 - <T as SystemService>::get_rockbox_version(&inner, request).await 9033 9033 + <T as SystemService>::get_rockbox_version(&inner, request) 9034 9034 + .await 7797 9035 }; 7798 9036 Box::pin(fut) 7799 9037 } ··· 7823 9061 "/rockbox.v1alpha1.SystemService/GetGlobalStatus" => { 7824 9062 #[allow(non_camel_case_types)] 7825 9063 struct GetGlobalStatusSvc<T: SystemService>(pub Arc<T>); 7826 7826 - impl<T: SystemService> 7827 7827 - tonic::server::UnaryService<super::GetGlobalStatusRequest> 7828 7828 - for GetGlobalStatusSvc<T> 7829 7829 - { 9064 9064 + impl< 9065 9065 + T: SystemService, 9066 9066 + > tonic::server::UnaryService<super::GetGlobalStatusRequest> 9067 9067 + for GetGlobalStatusSvc<T> { 7830 9068 type Response = super::GetGlobalStatusResponse; 7831 7831 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9069 9069 + type Future = BoxFuture< 9070 9070 + tonic::Response<Self::Response>, 9071 9071 + tonic::Status, 9072 9072 + >; 7832 9073 fn call( 7833 9074 &mut self, 7834 9075 request: tonic::Request<super::GetGlobalStatusRequest>, 7835 9076 ) -> Self::Future { 7836 9077 let inner = Arc::clone(&self.0); 7837 9078 let fut = async move { 7838 7838 - <T as SystemService>::get_global_status(&inner, request).await 9079 9079 + <T as SystemService>::get_global_status(&inner, request) 9080 9080 + .await 7839 9081 }; 7840 9082 Box::pin(fut) 7841 9083 } ··· 7862 9104 }; 7863 9105 Box::pin(fut) 7864 9106 } 7865 7865 - _ => Box::pin(async move { 7866 7866 - let mut response = http::Response::new(empty_body()); 7867 7867 - let headers = response.headers_mut(); 7868 7868 - headers.insert( 7869 7869 - tonic::Status::GRPC_STATUS, 7870 7870 - (tonic::Code::Unimplemented as i32).into(), 7871 7871 - ); 7872 7872 - headers.insert( 7873 7873 - http::header::CONTENT_TYPE, 7874 7874 - tonic::metadata::GRPC_CONTENT_TYPE, 7875 7875 - ); 7876 7876 - Ok(response) 7877 7877 - }), 9107 9107 + _ => { 9108 9108 + Box::pin(async move { 9109 9109 + let mut response = http::Response::new(empty_body()); 9110 9110 + let headers = response.headers_mut(); 9111 9111 + headers 9112 9112 + .insert( 9113 9113 + tonic::Status::GRPC_STATUS, 9114 9114 + (tonic::Code::Unimplemented as i32).into(), 9115 9115 + ); 9116 9116 + headers 9117 9117 + .insert( 9118 9118 + http::header::CONTENT_TYPE, 9119 9119 + tonic::metadata::GRPC_CONTENT_TYPE, 9120 9120 + ); 9121 9121 + Ok(response) 9122 9122 + }) 9123 9123 + } 7878 9124 } 7879 9125 } 7880 9126 }

+37 -7

cli/src/cmd/start.rs

··· 24 24 match wait_for_rockboxd(port.parse()?, Some(1)) { 25 25 Ok(_) => {} 26 26 Err(_) => { 27 27 - let mut child = Command::new("rockboxd") 28 28 - .env("SDL_VIDEODRIVER", video_driver) 29 29 - .env("ROCKBOX_PORT", port) 30 30 - .env("ROCKBOX_GRAPHQL_PORT", ui_port) 31 31 - .env("ROCKBOX_TCP_PORT", http_port) 32 32 - .spawn()?; 27 27 + #[cfg(target_os = "linux")] 28 28 + { 29 29 + let mut child = Command::new("rockboxd") 30 30 + .env("SDL_VIDEODRIVER", video_driver) 31 31 + .env("ROCKBOX_PORT", port) 32 32 + .env("ROCKBOX_GRAPHQL_PORT", ui_port) 33 33 + .env("ROCKBOX_TCP_PORT", http_port) 34 34 + .spawn()?; 33 35 34 34 - child.wait()?; 36 36 + child.wait()?; 37 37 + } 38 38 + #[cfg(target_os = "macos")] 39 39 + { 40 40 + use std::thread; 41 41 + 42 42 + thread::spawn(move || { 43 43 + let mut child = Command::new("rockboxd") 44 44 + .env("SDL_VIDEODRIVER", video_driver) 45 45 + .env("ROCKBOX_PORT", port) 46 46 + .env("ROCKBOX_GRAPHQL_PORT", ui_port) 47 47 + .env("ROCKBOX_TCP_PORT", http_port) 48 48 + .spawn()?; 49 49 + 50 50 + child.wait()?; 51 51 + Ok::<(), Error>(()) 52 52 + }); 53 53 + 54 54 + let port = env::var("ROCKBOX_PORT").unwrap_or_else(|_| "6061".to_string()); 55 55 + wait_for_rockboxd(port.parse()?, None)?; 56 56 + 57 57 + // On macOS, EventLoop must be created on the main thread. 58 58 + match rockbox_controls::run_media_controls() { 59 59 + Ok(_) => {} 60 60 + Err(e) => { 61 61 + eprintln!("Error starting rockbox controls: {}", e); 62 62 + } 63 63 + } 64 64 + } 35 65 } 36 66 }; 37 67 Ok(())

+20

crates/controls/Cargo.toml

··· 1 1 + [package] 2 2 + name = "rockbox-controls" 3 3 + version = "0.1.0" 4 4 + authors.workspace = true 5 5 + edition.workspace = true 6 6 + license.workspace = true 7 7 + repository.workspace = true 8 8 + 9 9 + [dependencies] 10 10 + anyhow = "1.0.93" 11 11 + prost = "0.13.2" 12 12 + rockbox-library = {path= "../library"} 13 13 + tokio = {version = "1.36.0", features = ["full"]} 14 14 + tonic = "0.12.3" 15 15 + urlencoding = "2.1.3" 16 16 + souvlaki = "0.8.3" 17 17 + winit = "0.30.12" 18 18 + 19 19 + [build-dependencies] 20 20 + tonic-build = "0.12.3"

+19

crates/controls/build.rs

··· 1 1 + fn main() -> Result<(), Box<dyn std::error::Error>> { 2 2 + tonic_build::configure() 3 3 + .out_dir("src/api") 4 4 + .file_descriptor_set_path("src/api/rockbox_descriptor.bin") 5 5 + .compile_protos( 6 6 + &[ 7 7 + "proto/rockbox/v1alpha1/browse.proto", 8 8 + "proto/rockbox/v1alpha1/library.proto", 9 9 + "proto/rockbox/v1alpha1/metadata.proto", 10 10 + "proto/rockbox/v1alpha1/playback.proto", 11 11 + "proto/rockbox/v1alpha1/playlist.proto", 12 12 + "proto/rockbox/v1alpha1/settings.proto", 13 13 + "proto/rockbox/v1alpha1/sound.proto", 14 14 + "proto/rockbox/v1alpha1/system.proto", 15 15 + ], 16 16 + &["proto"], 17 17 + )?; 18 18 + Ok(()) 19 19 + }

+11

crates/controls/proto/buf.yaml

··· 1 1 + # For details on buf.yaml configuration, visit https://buf.build/docs/configuration/v2/buf-yaml 2 2 + version: v2 3 3 + modules: 4 4 + - path: . 5 5 + name: buf.build/tsiry/rockboxapis 6 6 + lint: 7 7 + use: 8 8 + - STANDARD 9 9 + breaking: 10 10 + use: 11 11 + - FILE

+38

crates/controls/proto/rockbox/v1alpha1/browse.proto

··· 1 1 + syntax = "proto3"; 2 2 + 3 3 + package rockbox.v1alpha1; 4 4 + 5 5 + message RockboxBrowseRequest {} 6 6 + 7 7 + message RockboxBrowseResponse {} 8 8 + 9 9 + message TreeGetContextRequest {} 10 10 + 11 11 + message TreeGetContextResponse {} 12 12 + 13 13 + message TreeGetEntriesRequest { 14 14 + optional string path = 1; 15 15 + } 16 16 + 17 17 + message Entry { 18 18 + string name = 1; 19 19 + int32 attr = 2; 20 20 + uint32 time_write = 3; 21 21 + int32 customaction = 4; 22 22 + } 23 23 + 24 24 + message TreeGetEntriesResponse { 25 25 + repeated Entry entries = 1; 26 26 + } 27 27 + 28 28 + message TreeGetEntryAtRequest {} 29 29 + 30 30 + message TreeGetEntryAtResponse {} 31 31 + 32 32 + message BrowseId3Request {} 33 33 + 34 34 + message BrowseId3Response {} 35 35 + 36 36 + service BrowseService { 37 37 + rpc TreeGetEntries(TreeGetEntriesRequest) returns (TreeGetEntriesResponse); 38 38 + }

+55

crates/controls/proto/rockbox/v1alpha1/device.proto

··· 1 1 + syntax = "proto3"; 2 2 + 3 3 + package rockbox.v1alpha1; 4 4 + 5 5 + message GetDevicesRequest {} 6 6 + 7 7 + message GetDevicesResponse { 8 8 + repeated Device devices = 1; 9 9 + } 10 10 + 11 11 + message GetDeviceRequest { 12 12 + string id = 1; 13 13 + } 14 14 + 15 15 + message GetDeviceResponse { 16 16 + Device device = 1; 17 17 + } 18 18 + 19 19 + message ConnectDeviceRequest { 20 20 + string id = 1; 21 21 + } 22 22 + 23 23 + message ConnectDeviceResponse { 24 24 + Device device = 1; 25 25 + } 26 26 + 27 27 + message DisconnectDeviceRequest { 28 28 + string id = 1; 29 29 + } 30 30 + 31 31 + message DisconnectDeviceResponse { 32 32 + Device device = 1; 33 33 + } 34 34 + 35 35 + message Device { 36 36 + string id = 1; 37 37 + string name = 2; 38 38 + string host = 3; 39 39 + string ip = 4; 40 40 + uint32 port = 5; 41 41 + string service = 6; 42 42 + string app = 7; 43 43 + bool is_connected = 8; 44 44 + optional string base_url = 9; 45 45 + bool is_cast_device = 10; 46 46 + bool is_source_device = 11; 47 47 + bool is_current_device = 12; 48 48 + } 49 49 + 50 50 + service DeviceService { 51 51 + rpc GetDevices(GetDevicesRequest) returns (GetDevicesResponse); 52 52 + rpc GetDevice(GetDeviceRequest) returns (GetDeviceResponse); 53 53 + rpc ConnectDevice(ConnectDeviceRequest) returns (ConnectDeviceResponse); 54 54 + rpc DisconnectDevice(DisconnectDeviceRequest) returns (DisconnectDeviceResponse); 55 55 + }

+161

crates/controls/proto/rockbox/v1alpha1/library.proto

··· 1 1 + syntax = "proto3"; 2 2 + 3 3 + package rockbox.v1alpha1; 4 4 + 5 5 + message Track { 6 6 + string id = 1; 7 7 + string path = 2; 8 8 + string title = 3; 9 9 + string artist = 4; 10 10 + string album = 5; 11 11 + string album_artist = 6; 12 12 + uint32 bitrate = 7; 13 13 + string composer = 8; 14 14 + uint32 disc_number = 9; 15 15 + uint32 filesize = 10; 16 16 + uint32 frequency = 11; 17 17 + uint32 length = 12; 18 18 + uint32 track_number = 13; 19 19 + uint32 year = 14; 20 20 + string year_string = 15; 21 21 + string genre = 16; 22 22 + string md5 = 17; 23 23 + optional string album_art = 18; 24 24 + optional string artist_id = 19; 25 25 + optional string album_id = 20; 26 26 + optional string genre_id = 21; 27 27 + string created_at = 22; 28 28 + string updated_at = 23; 29 29 + } 30 30 + 31 31 + message Artist { 32 32 + string id = 1; 33 33 + string name = 2; 34 34 + optional string bio = 3; 35 35 + optional string image = 4; 36 36 + repeated Album albums = 5; 37 37 + repeated Track tracks = 6; 38 38 + } 39 39 + 40 40 + message Album { 41 41 + string id = 1; 42 42 + string title = 2; 43 43 + string artist = 3; 44 44 + uint32 year = 4; 45 45 + string year_string = 5; 46 46 + optional string album_art = 6; 47 47 + string md5 = 7; 48 48 + string artist_id = 8; 49 49 + repeated Track tracks = 9; 50 50 + } 51 51 + 52 52 + message GetAlbumRequest { 53 53 + string id = 1; 54 54 + } 55 55 + 56 56 + message GetAlbumResponse { 57 57 + optional Album album = 1; 58 58 + } 59 59 + 60 60 + message GetArtistRequest { 61 61 + string id = 1; 62 62 + } 63 63 + 64 64 + message GetArtistResponse { 65 65 + optional Artist artist = 1; 66 66 + } 67 67 + 68 68 + message GetTrackRequest { 69 69 + string id = 1; 70 70 + } 71 71 + 72 72 + message GetTrackResponse { 73 73 + optional Track track = 1; 74 74 + } 75 75 + 76 76 + message GetAlbumsRequest {} 77 77 + 78 78 + message GetAlbumsResponse { 79 79 + repeated Album albums = 1; 80 80 + } 81 81 + 82 82 + message GetArtistsRequest {} 83 83 + 84 84 + message GetArtistsResponse { 85 85 + repeated Artist artists = 1; 86 86 + } 87 87 + 88 88 + message GetTracksRequest {} 89 89 + 90 90 + message GetTracksResponse { 91 91 + repeated Track tracks = 1; 92 92 + } 93 93 + 94 94 + message LikeTrackRequest { 95 95 + string id = 1; 96 96 + } 97 97 + 98 98 + message LikeTrackResponse {} 99 99 + 100 100 + message LikeAlbumRequest { 101 101 + string id = 1; 102 102 + } 103 103 + 104 104 + message LikeAlbumResponse {} 105 105 + 106 106 + message UnlikeTrackRequest { 107 107 + string id = 1; 108 108 + } 109 109 + 110 110 + message UnlikeTrackResponse {} 111 111 + 112 112 + message UnlikeAlbumRequest { 113 113 + string id = 1; 114 114 + } 115 115 + 116 116 + message UnlikeAlbumResponse {} 117 117 + 118 118 + message GetLikedTracksRequest {} 119 119 + 120 120 + message GetLikedTracksResponse { 121 121 + repeated Track tracks = 1; 122 122 + } 123 123 + 124 124 + message GetLikedAlbumsRequest {} 125 125 + 126 126 + message GetLikedAlbumsResponse { 127 127 + repeated Album albums = 1; 128 128 + } 129 129 + 130 130 + message ScanLibraryRequest { 131 131 + optional string path = 1; 132 132 + } 133 133 + 134 134 + message ScanLibraryResponse {} 135 135 + 136 136 + message SearchRequest { 137 137 + string term = 1; 138 138 + } 139 139 + 140 140 + message SearchResponse { 141 141 + repeated Track tracks = 1; 142 142 + repeated Album albums = 2; 143 143 + repeated Artist artists = 3; 144 144 + } 145 145 + 146 146 + service LibraryService { 147 147 + rpc GetAlbums(GetAlbumsRequest) returns (GetAlbumsResponse); 148 148 + rpc GetArtists(GetArtistsRequest) returns (GetArtistsResponse); 149 149 + rpc GetTracks(GetTracksRequest) returns (GetTracksResponse); 150 150 + rpc GetAlbum(GetAlbumRequest) returns (GetAlbumResponse); 151 151 + rpc GetArtist(GetArtistRequest) returns (GetArtistResponse); 152 152 + rpc GetTrack(GetTrackRequest) returns (GetTrackResponse); 153 153 + rpc LikeTrack(LikeTrackRequest) returns (LikeTrackResponse); 154 154 + rpc UnlikeTrack(UnlikeTrackRequest) returns (UnlikeTrackResponse); 155 155 + rpc LikeAlbum(LikeAlbumRequest) returns (LikeAlbumResponse); 156 156 + rpc UnlikeAlbum(UnlikeAlbumRequest) returns (UnlikeAlbumResponse); 157 157 + rpc GetLikedTracks(GetLikedTracksRequest) returns (GetLikedTracksResponse); 158 158 + rpc GetLikedAlbums(GetLikedAlbumsRequest) returns (GetLikedAlbumsResponse); 159 159 + rpc ScanLibrary(ScanLibraryRequest) returns (ScanLibraryResponse); 160 160 + rpc Search(SearchRequest) returns (SearchResponse); 161 161 + }

+7

crates/controls/proto/rockbox/v1alpha1/metadata.proto

··· 1 1 + syntax = "proto3"; 2 2 + 3 3 + package rockbox.v1alpha1; 4 4 + 5 5 + service MetadataService { 6 6 + 7 7 + }

+202

crates/controls/proto/rockbox/v1alpha1/playback.proto

··· 1 1 + syntax = "proto3"; 2 2 + 3 3 + package rockbox.v1alpha1; 4 4 + 5 5 + message PlayRequest { 6 6 + int64 elapsed = 1; 7 7 + int64 offset = 2; 8 8 + } 9 9 + 10 10 + message PlayResponse {} 11 11 + 12 12 + message PauseRequest {} 13 13 + 14 14 + message PlayOrPauseRequest {} 15 15 + 16 16 + message PlayOrPauseResponse {} 17 17 + 18 18 + message PauseResponse {} 19 19 + 20 20 + message ResumeRequest {} 21 21 + 22 22 + message ResumeResponse {} 23 23 + 24 24 + message NextRequest {} 25 25 + 26 26 + message NextResponse {} 27 27 + 28 28 + message PreviousRequest {} 29 29 + 30 30 + message PreviousResponse {} 31 31 + 32 32 + message FastForwardRewindRequest { 33 33 + int32 new_time = 1; 34 34 + } 35 35 + 36 36 + message FastForwardRewindResponse {} 37 37 + 38 38 + message StatusRequest {} 39 39 + 40 40 + message StreamStatusRequest {} 41 41 + 42 42 + message StatusResponse { 43 43 + int32 status = 1; 44 44 + } 45 45 + 46 46 + message CurrentTrackRequest {} 47 47 + 48 48 + message CurrentTrackResponse { 49 49 + string title = 1; 50 50 + string artist = 2; 51 51 + string album = 3; 52 52 + string genre = 4; 53 53 + string disc = 5; 54 54 + string track_string = 6; 55 55 + string year_string = 7; 56 56 + string composer = 8; 57 57 + string comment = 9; 58 58 + string album_artist = 10; 59 59 + string grouping = 11; 60 60 + int32 discnum = 12; 61 61 + int32 tracknum = 13; 62 62 + int32 layer = 14; 63 63 + int32 year = 15; 64 64 + uint32 bitrate = 16; 65 65 + uint64 frequency = 17; 66 66 + uint64 filesize = 18; 67 67 + uint64 length = 19; 68 68 + uint64 elapsed = 20; 69 69 + string path = 21; 70 70 + optional string album_art = 22; 71 71 + string album_id = 23; 72 72 + string artist_id = 24; 73 73 + string id = 25; 74 74 + } 75 75 + 76 76 + message StreamCurrentTrackRequest {} 77 77 + 78 78 + message NextTrackRequest {} 79 79 + 80 80 + message NextTrackResponse { 81 81 + string title = 1; 82 82 + string artist = 2; 83 83 + string album = 3; 84 84 + string genre = 4; 85 85 + string disc = 5; 86 86 + string track_string = 6; 87 87 + string year_string = 7; 88 88 + string composer = 8; 89 89 + string comment = 9; 90 90 + string album_artist = 10; 91 91 + string grouping = 11; 92 92 + int32 discnum = 12; 93 93 + int32 tracknum = 13; 94 94 + int32 layer = 14; 95 95 + int32 year = 15; 96 96 + uint32 bitrate = 16; 97 97 + uint64 frequency = 17; 98 98 + uint64 filesize = 18; 99 99 + uint64 length = 19; 100 100 + uint64 elapsed = 20; 101 101 + string path = 21; 102 102 + } 103 103 + 104 104 + message FlushAndReloadTracksRequest {} 105 105 + 106 106 + message FlushAndReloadTracksResponse {} 107 107 + 108 108 + message GetFilePositionRequest {} 109 109 + 110 110 + message GetFilePositionResponse { 111 111 + int32 position = 1; 112 112 + } 113 113 + 114 114 + message HardStopRequest {} 115 115 + 116 116 + message HardStopResponse {} 117 117 + 118 118 + message PlayAlbumRequest { 119 119 + string album_id = 1; 120 120 + optional bool shuffle = 2; 121 121 + optional int32 position = 3; 122 122 + } 123 123 + 124 124 + message PlayAlbumResponse {} 125 125 + 126 126 + message PlayArtistTracksRequest { 127 127 + string artist_id = 1; 128 128 + optional bool shuffle = 2; 129 129 + optional int32 position = 3; 130 130 + } 131 131 + 132 132 + message PlayArtistTracksResponse {} 133 133 + 134 134 + message PlayPlaylistRequest { 135 135 + string playlist_id = 1; 136 136 + optional bool shuffle = 2; 137 137 + } 138 138 + 139 139 + message PlayPlaylistResponse {} 140 140 + 141 141 + message PlayDirectoryRequest { 142 142 + string path = 1; 143 143 + optional bool shuffle = 2; 144 144 + optional bool recurse = 3; 145 145 + optional int32 position = 4; 146 146 + } 147 147 + 148 148 + message PlayDirectoryResponse {} 149 149 + 150 150 + message PlayTrackRequest { 151 151 + string path = 1; 152 152 + } 153 153 + 154 154 + message PlayTrackResponse {} 155 155 + 156 156 + message PlayLikedTracksRequest { 157 157 + optional bool shuffle = 1; 158 158 + optional int32 position = 2; 159 159 + } 160 160 + 161 161 + message PlayLikedTracksResponse {} 162 162 + 163 163 + message PlayAllTracksRequest { 164 164 + optional bool shuffle = 1; 165 165 + optional int32 position = 2; 166 166 + } 167 167 + 168 168 + message PlayAllTracksResponse {} 169 169 + 170 170 + message StreamPlaylistRequest {} 171 171 + 172 172 + message PlaylistResponse { 173 173 + int32 index = 1; 174 174 + int32 amount = 2; 175 175 + repeated CurrentTrackResponse tracks = 3; 176 176 + } 177 177 + 178 178 + service PlaybackService { 179 179 + rpc Play(PlayRequest) returns (PlayResponse) {} 180 180 + rpc Pause(PauseRequest) returns (PauseResponse) {} 181 181 + rpc PlayOrPause(PlayOrPauseRequest) returns (PlayOrPauseResponse) {} 182 182 + rpc Resume(ResumeRequest) returns (ResumeResponse) {} 183 183 + rpc Next(NextRequest) returns (NextResponse) {} 184 184 + rpc Previous(PreviousRequest) returns (PreviousResponse) {} 185 185 + rpc FastForwardRewind(FastForwardRewindRequest) returns (FastForwardRewindResponse) {} 186 186 + rpc Status(StatusRequest) returns (StatusResponse) {} 187 187 + rpc CurrentTrack(CurrentTrackRequest) returns (CurrentTrackResponse) {} 188 188 + rpc NextTrack(NextTrackRequest) returns (NextTrackResponse) {} 189 189 + rpc FlushAndReloadTracks(FlushAndReloadTracksRequest) returns (FlushAndReloadTracksResponse) {} 190 190 + rpc GetFilePosition(GetFilePositionRequest) returns (GetFilePositionResponse) {} 191 191 + rpc HardStop(HardStopRequest) returns (HardStopResponse) {} 192 192 + rpc PlayAlbum(PlayAlbumRequest) returns (PlayAlbumResponse) {} 193 193 + rpc PlayArtistTracks(PlayArtistTracksRequest) returns (PlayArtistTracksResponse) {} 194 194 + rpc PlayPlaylist(PlayPlaylistRequest) returns (PlayPlaylistResponse) {} 195 195 + rpc PlayDirectory(PlayDirectoryRequest) returns (PlayDirectoryResponse) {} 196 196 + rpc PlayTrack(PlayTrackRequest) returns (PlayTrackResponse) {} 197 197 + rpc PlayLikedTracks(PlayLikedTracksRequest) returns (PlayLikedTracksResponse) {} 198 198 + rpc PlayAllTracks(PlayAllTracksRequest) returns (PlayAllTracksResponse) {} 199 199 + rpc StreamCurrentTrack(StreamCurrentTrackRequest) returns (stream CurrentTrackResponse) {} 200 200 + rpc StreamStatus(StreamStatusRequest) returns (stream StatusResponse) {} 201 201 + rpc StreamPlaylist(StreamPlaylistRequest) returns (stream PlaylistResponse) {} 202 202 + }

+159

crates/controls/proto/rockbox/v1alpha1/playlist.proto

··· 1 1 + syntax = "proto3"; 2 2 + 3 3 + package rockbox.v1alpha1; 4 4 + 5 5 + import "rockbox/v1alpha1/playback.proto"; 6 6 + 7 7 + message GetCurrentRequest {} 8 8 + 9 9 + message GetCurrentResponse { 10 10 + int32 index = 1; 11 11 + int32 amount = 2; 12 12 + int32 max_playlist_size = 3; 13 13 + int32 first_index = 4; 14 14 + int32 last_insert_pos = 5; 15 15 + int32 seed = 6; 16 16 + int32 last_shuffled_start = 7; 17 17 + repeated rockbox.v1alpha1.CurrentTrackResponse tracks = 8; 18 18 + } 19 19 + 20 20 + message GetResumeInfoRequest {} 21 21 + 22 22 + message GetResumeInfoResponse {} 23 23 + 24 24 + message GetTrackInfoRequest {} 25 25 + 26 26 + message GetTrackInfoResponse {} 27 27 + 28 28 + message GetFirstIndexRequest {} 29 29 + 30 30 + message GetFirstIndexResponse {} 31 31 + 32 32 + message GetDisplayIndexRequest {} 33 33 + 34 34 + message GetDisplayIndexResponse {} 35 35 + 36 36 + message AmountRequest {} 37 37 + 38 38 + message AmountResponse { int32 amount = 1; } 39 39 + 40 40 + message PlaylistResumeRequest {} 41 41 + 42 42 + message PlaylistResumeResponse { int32 code = 1; } 43 43 + 44 44 + message ResumeTrackRequest { 45 45 + int32 start_index = 1; 46 46 + uint32 crc = 2; 47 47 + uint64 elapsed = 3; 48 48 + uint64 offset = 4; 49 49 + } 50 50 + 51 51 + message ResumeTrackResponse {} 52 52 + 53 53 + message SetModifiedRequest {} 54 54 + 55 55 + message SetModifiedResponse {} 56 56 + 57 57 + message StartRequest { 58 58 + optional int32 start_index = 1; 59 59 + optional int32 elapsed = 2; 60 60 + optional int32 offset = 3; 61 61 + } 62 62 + 63 63 + message StartResponse {} 64 64 + 65 65 + message SyncRequest {} 66 66 + 67 67 + message SyncResponse {} 68 68 + 69 69 + message RemoveAllTracksRequest {} 70 70 + 71 71 + message RemoveAllTracksResponse {} 72 72 + 73 73 + message RemoveTracksRequest { repeated int32 positions = 1; } 74 74 + 75 75 + message RemoveTracksResponse {} 76 76 + 77 77 + message CreatePlaylistRequest { 78 78 + string name = 1; 79 79 + repeated string tracks = 2; 80 80 + optional string folder_id = 3; 81 81 + } 82 82 + 83 83 + message CreatePlaylistResponse { int32 start_index = 1; } 84 84 + 85 85 + message InsertTracksRequest { 86 86 + optional string playlist_id = 1; 87 87 + int32 position = 2; 88 88 + repeated string tracks = 3; 89 89 + optional bool shuffle = 4; 90 90 + } 91 91 + 92 92 + message InsertTracksResponse {} 93 93 + 94 94 + message InsertDirectoryRequest { 95 95 + optional string playlist_id = 1; 96 96 + int32 position = 2; 97 97 + string directory = 3; 98 98 + optional bool recurse = 4; 99 99 + optional bool shuffle = 5; 100 100 + } 101 101 + 102 102 + message InsertDirectoryResponse {} 103 103 + 104 104 + message InsertPlaylistRequest { 105 105 + int32 position = 1; 106 106 + string target_playlist_id = 2; 107 107 + string playlist_id = 3; 108 108 + optional bool shuffle = 4; 109 109 + } 110 110 + 111 111 + message InsertPlaylistResponse {} 112 112 + 113 113 + message InsertAlbumRequest { 114 114 + int32 position = 1; 115 115 + string album_id = 2; 116 116 + optional bool shuffle = 3; 117 117 + } 118 118 + 119 119 + message InsertAlbumResponse {} 120 120 + 121 121 + message InsertArtistTracksRequest { 122 122 + int32 position = 1; 123 123 + string artist_id = 2; 124 124 + optional bool shuffle = 3; 125 125 + } 126 126 + 127 127 + message InsertArtistTracksResponse {} 128 128 + 129 129 + message ShufflePlaylistRequest { int32 start_index = 1; } 130 130 + 131 131 + message ShufflePlaylistResponse {} 132 132 + 133 133 + service PlaylistService { 134 134 + rpc GetCurrent(GetCurrentRequest) returns (GetCurrentResponse) {} 135 135 + rpc GetResumeInfo(GetResumeInfoRequest) returns (GetResumeInfoResponse) {} 136 136 + rpc GetTrackInfo(GetTrackInfoRequest) returns (GetTrackInfoResponse) {} 137 137 + rpc GetFirstIndex(GetFirstIndexRequest) returns (GetFirstIndexResponse) {} 138 138 + rpc GetDisplayIndex(GetDisplayIndexRequest) 139 139 + returns (GetDisplayIndexResponse) {} 140 140 + rpc Amount(AmountRequest) returns (AmountResponse) {} 141 141 + rpc PlaylistResume(PlaylistResumeRequest) returns (PlaylistResumeResponse) {} 142 142 + rpc ResumeTrack(ResumeTrackRequest) returns (ResumeTrackResponse) {} 143 143 + rpc SetModified(SetModifiedRequest) returns (SetModifiedResponse) {} 144 144 + rpc Start(StartRequest) returns (StartResponse) {} 145 145 + rpc Sync(SyncRequest) returns (SyncResponse) {} 146 146 + rpc RemoveAllTracks(RemoveAllTracksRequest) 147 147 + returns (RemoveAllTracksResponse) {} 148 148 + rpc RemoveTracks(RemoveTracksRequest) returns (RemoveTracksResponse) {} 149 149 + rpc CreatePlaylist(CreatePlaylistRequest) returns (CreatePlaylistResponse) {} 150 150 + rpc InsertTracks(InsertTracksRequest) returns (InsertTracksResponse) {} 151 151 + rpc InsertDirectory(InsertDirectoryRequest) 152 152 + returns (InsertDirectoryResponse) {} 153 153 + rpc InsertPlaylist(InsertPlaylistRequest) returns (InsertPlaylistResponse) {} 154 154 + rpc InsertAlbum(InsertAlbumRequest) returns (InsertAlbumResponse) {} 155 155 + rpc InsertArtistTracks(InsertArtistTracksRequest) 156 156 + returns (InsertArtistTracksResponse) {} 157 157 + rpc ShufflePlaylist(ShufflePlaylistRequest) 158 158 + returns (ShufflePlaylistResponse) {} 159 159 + }

+262

crates/controls/proto/rockbox/v1alpha1/settings.proto

··· 1 1 + syntax = "proto3"; 2 2 + 3 3 + package rockbox.v1alpha1; 4 4 + 5 5 + message GetSettingsListRequest { 6 6 + int32 count = 1; 7 7 + } 8 8 + 9 9 + message GetSettingsListResponse {} 10 10 + 11 11 + message GetGlobalSettingsRequest {} 12 12 + 13 13 + message ReplaygainSettings { 14 14 + bool noclip = 1; 15 15 + int32 type = 2; 16 16 + int32 preamp = 3; 17 17 + } 18 18 + 19 19 + message EqBandSetting { 20 20 + int32 cutoff = 1; 21 21 + int32 q = 2; 22 22 + int32 gain = 3; 23 23 + } 24 24 + 25 25 + message SettingsList { 26 26 + uint32 flags = 1; 27 27 + int32 lang_id = 2; 28 28 + string cfg_name = 3; 29 29 + string cfg_vals = 4; 30 30 + } 31 31 + 32 32 + message CompressorSettings { 33 33 + int32 threshold = 1; 34 34 + int32 makeup_gain = 2; 35 35 + int32 ratio = 3; 36 36 + int32 knee = 4; 37 37 + int32 release_time = 5; 38 38 + int32 attack_time = 6; 39 39 + } 40 40 + 41 41 + message GetGlobalSettingsResponse { 42 42 + int32 volume = 1; 43 43 + int32 balance = 2; 44 44 + int32 bass = 3; 45 45 + int32 treble = 4; 46 46 + int32 channel_config = 5; 47 47 + int32 stereo_width = 6; 48 48 + int32 bass_cutoff = 7; 49 49 + int32 treble_cutoff = 8; 50 50 + int32 crossfade = 9; 51 51 + int32 crossfade_fade_in_delay = 10; 52 52 + int32 crossfade_fade_out_delay = 11; 53 53 + int32 crossfade_fade_in_duration = 12; 54 54 + int32 crossfade_fade_out_duration = 13; 55 55 + int32 crossfade_fade_out_mixmode = 14; 56 56 + ReplaygainSettings replaygain_settings = 15; 57 57 + int32 crossfeed = 16; 58 58 + uint32 crossfeed_direct_gain = 17; 59 59 + uint32 crossfeed_cross_gain = 18; 60 60 + uint32 crossfeed_hf_attenuation = 19; 61 61 + uint32 crossfeed_hf_cutoff = 20; 62 62 + bool eq_enabled = 21; 63 63 + uint32 eq_precut = 22; 64 64 + repeated EqBandSetting eq_band_settings = 23; 65 65 + int32 beep = 24; 66 66 + int32 keyclick = 25; 67 67 + int32 keyclick_repeats = 26; 68 68 + bool dithering_enabled = 27; 69 69 + bool timestretch_enabled = 28; 70 70 + int32 list_accel_start_delay = 29; 71 71 + int32 list_accel_wait = 30; 72 72 + int32 touchpad_sensitivity = 31; 73 73 + int32 touchpad_deadzone = 32; 74 74 + int32 pause_rewind = 33; 75 75 + int32 unplug_mode = 34; 76 76 + bool unplug_autoresume = 35; 77 77 + int32 timeformat = 37; 78 78 + int32 disk_spindown = 38; 79 79 + int32 buffer_margin = 39; 80 80 + int32 dirfilter = 40; 81 81 + int32 show_filename_ext = 41; 82 82 + int32 default_codepage = 42; 83 83 + bool hold_lr_for_scroll_in_list = 43; 84 84 + bool play_selected = 44; 85 85 + int32 single_mode = 45; 86 86 + bool party_mode = 46; 87 87 + bool car_adapter_mode = 48; 88 88 + int32 car_adapter_mode_delay = 49; 89 89 + int32 start_in_screen = 50; 90 90 + int32 ff_rewind_min_step = 51; 91 91 + int32 ff_rewind_accel = 52; 92 92 + int32 peak_meter_release = 53; 93 93 + int32 peak_meter_hold = 54; 94 94 + int32 peak_meter_clip_hold = 55; 95 95 + bool peak_meter_dbfs = 56; 96 96 + int32 peak_meter_min = 57; 97 97 + int32 peak_meter_max = 58; 98 98 + string wps_file = 59; 99 99 + string sbs_file = 60; 100 100 + string lang_file = 61; 101 101 + string playlist_catalog_dir = 62; 102 102 + int32 skip_length = 63; 103 103 + int32 max_files_in_dir = 64; 104 104 + int32 max_files_in_playlist = 65; 105 105 + int32 volume_type = 66; 106 106 + int32 battery_display = 67; 107 107 + bool show_icons = 68; 108 108 + int32 statusbar = 69; 109 109 + int32 scrollbar = 70; 110 110 + int32 scrollbar_width = 71; 111 111 + int32 list_line_padding = 72; 112 112 + int32 list_separator_color = 73; 113 113 + bool browse_current = 74; 114 114 + bool scroll_paginated = 75; 115 115 + bool list_wraparound = 76; 116 116 + int32 list_order = 77; 117 117 + int32 scroll_speed = 78; 118 118 + int32 bidir_limit = 79; 119 119 + int32 scroll_delay = 80; 120 120 + int32 scroll_step = 81; 121 121 + int32 autoloadbookmark = 82; 122 122 + int32 autocreatebookmark = 83; 123 123 + bool autoupdatebookmark = 84; 124 124 + int32 usemrb = 85; 125 125 + bool dircache = 86; 126 126 + int32 tagcache_ram = 87; 127 127 + bool tagcache_autoupdate = 88; 128 128 + bool autoresume_enable = 89; 129 129 + int32 autoresume_automatic = 90; 130 130 + string autoresume_paths = 91; 131 131 + bool runtimedb = 92; 132 132 + string tagcache_scan_paths = 93; 133 133 + string tagcache_db_path = 94; 134 134 + string backdrop_file = 95; 135 135 + int32 bg_color = 96; 136 136 + int32 fg_color = 97; 137 137 + int32 lss_color = 98; 138 138 + int32 lse_color = 99; 139 139 + int32 lst_color = 100; 140 140 + string colors_file = 101; 141 141 + int32 browser_default = 102; 142 142 + int32 repeat_mode = 103; 143 143 + int32 next_folder = 104; 144 144 + bool constrain_next_folder = 105; 145 145 + int32 recursive_dir_insert = 106; 146 146 + bool fade_on_stop = 107; 147 147 + bool playlist_shuffle = 108; 148 148 + bool warnon_erase_dynplaylist = 109; 149 149 + bool keep_current_track_on_replace_playlist = 110; 150 150 + bool show_shuffled_adding_options = 111; 151 151 + int32 show_queue_options = 112; 152 152 + int32 album_art = 113; 153 153 + bool rewind_across_tracks = 114; 154 154 + bool playlist_viewer_icons = 115; 155 155 + bool playlist_viewer_indices = 116; 156 156 + int32 playlist_viewer_track_display = 117; 157 157 + bool sort_case = 118; 158 158 + int32 sort_dir = 119; 159 159 + int32 sort_file = 120; 160 160 + int32 interpret_numbers = 121; 161 161 + int32 poweroff = 122; 162 162 + bool spdif_enable = 123; 163 163 + int32 contrast = 124; 164 164 + bool invert = 125; 165 165 + bool flip_display = 126; 166 166 + int32 cursor_style = 127; 167 167 + int32 screen_scroll_step = 128; 168 168 + int32 show_path_in_browser = 129; 169 169 + bool offset_out_of_view = 130; 170 170 + bool disable_mainmenu_scrolling = 131; 171 171 + string icon_file = 132; 172 172 + string viewers_icon_file = 133; 173 173 + string font_file = 134; 174 174 + int32 glyphs_to_cache = 135; 175 175 + string kbd_file = 136; 176 176 + int32 backlight_timeout = 137; 177 177 + bool caption_backlight = 138; 178 178 + bool bl_filter_first_keypress = 139; 179 179 + int32 backlight_timeout_plugged = 140; 180 180 + bool bt_selective_softlock_actions = 141; 181 181 + int32 bt_selective_softlock_actions_mask = 142; 182 182 + bool bl_selective_actions = 143; 183 183 + int32 bl_selective_actions_mask = 144; 184 184 + int32 backlight_on_button_hold = 145; 185 185 + int32 lcd_sleep_after_backlight_off = 146; 186 186 + int32 brightness = 147; 187 187 + int32 speaker_mode = 148; 188 188 + bool prevent_skip = 149; 189 189 + int32 touch_mode = 150; 190 190 + bool pitch_mode_semitone = 151; 191 191 + bool pitch_mode_timestretch = 152; 192 192 + string player_name = 153; 193 193 + CompressorSettings compressor_settings = 154; 194 194 + int32 sleeptimer_duration = 155; 195 195 + bool sleeptimer_on_startup = 156; 196 196 + bool keypress_restarts_sleeptimer = 157; 197 197 + bool show_shutdown_message = 158; 198 198 + int32 hotkey_wps = 159; 199 199 + int32 hotkey_tree = 160; 200 200 + int32 resume_rewind = 161; 201 201 + int32 depth_3d = 162; 202 202 + int32 roll_off = 163; 203 203 + int32 power_mode = 164; 204 204 + bool keyclick_hardware = 165; 205 205 + string start_directory = 166; 206 206 + bool root_menu_customized = 167; 207 207 + bool shortcuts_replaces_qs = 168; 208 208 + int32 play_frequency = 169; 209 209 + int32 volume_limit = 170; 210 210 + int32 volume_adjust_mode = 171; 211 211 + int32 volume_adjust_norm_steps = 172; 212 212 + int32 surround_enabled = 173; 213 213 + int32 surround_balance = 174; 214 214 + int32 surround_fx1 = 175; 215 215 + int32 surround_fx2 = 176; 216 216 + bool surround_method2 = 177; 217 217 + int32 surround_mix = 178; 218 218 + int32 pbe = 179; 219 219 + int32 pbe_precut = 180; 220 220 + int32 afr_enabled = 181; 221 221 + int32 governor = 182; 222 222 + int32 stereosw_mode = 183; 223 223 + string music_dir = 184; 224 224 + } 225 225 + 226 226 + message SaveSettingsRequest { 227 227 + optional string music_dir = 1; 228 228 + optional bool playlist_shuffle = 2; 229 229 + optional int32 repeat_mode = 3; 230 230 + optional int32 bass = 4; 231 231 + optional int32 treble = 5; 232 232 + optional int32 bass_cutoff = 6; 233 233 + optional int32 treble_cutoff = 7; 234 234 + optional int32 crossfade = 8; 235 235 + optional bool fade_on_stop = 9; 236 236 + optional int32 fade_in_delay = 10; 237 237 + optional int32 fade_in_duration = 11; 238 238 + optional int32 fade_out_delay = 12; 239 239 + optional int32 fade_out_duration = 13; 240 240 + optional int32 fade_out_mixmode = 14; 241 241 + optional int32 balance = 15; 242 242 + optional int32 stereo_width = 16; 243 243 + optional int32 stereosw_mode = 17; 244 244 + optional int32 surround_enabled = 18; 245 245 + optional int32 surround_balance = 19; 246 246 + optional int32 surround_fx1 = 20; 247 247 + optional int32 surround_fx2 = 21; 248 248 + optional bool party_mode = 22; 249 249 + optional int32 channel_config = 23; 250 250 + optional string player_name = 24; 251 251 + optional bool eq_enabled = 25; 252 252 + repeated EqBandSetting eq_band_settings = 26; 253 253 + optional ReplaygainSettings replaygain_settings = 27; 254 254 + } 255 255 + 256 256 + message SaveSettingsResponse {} 257 257 + 258 258 + service SettingsService { 259 259 + rpc GetSettingsList(GetSettingsListRequest) returns (GetSettingsListResponse); 260 260 + rpc GetGlobalSettings(GetGlobalSettingsRequest) returns (GetGlobalSettingsResponse); 261 261 + rpc SaveSettings(SaveSettingsRequest) returns (SaveSettingsResponse); 262 262 + }

+126

crates/controls/proto/rockbox/v1alpha1/sound.proto

··· 1 1 + syntax = "proto3"; 2 2 + 3 3 + package rockbox.v1alpha1; 4 4 + 5 5 + message AdjustVolumeRequest { 6 6 + int32 steps = 1; 7 7 + } 8 8 + 9 9 + message AdjustVolumeResponse { 10 10 + } 11 11 + 12 12 + message SoundSetRequest { 13 13 + int32 setting = 1; 14 14 + int32 value = 2; 15 15 + } 16 16 + 17 17 + message SoundSetResponse {} 18 18 + 19 19 + message SoundCurrentRequest { 20 20 + int32 setting = 1; 21 21 + } 22 22 + 23 23 + message SoundCurrentResponse { 24 24 + int32 value = 1; 25 25 + } 26 26 + 27 27 + message SoundDefaultRequest { 28 28 + int32 setting = 1; 29 29 + } 30 30 + 31 31 + message SoundDefaultResponse { 32 32 + int32 value = 1; 33 33 + } 34 34 + 35 35 + message SoundMinRequest { 36 36 + int32 setting = 1; 37 37 + } 38 38 + 39 39 + message SoundMinResponse { 40 40 + int32 value = 1; 41 41 + } 42 42 + 43 43 + message SoundMaxRequest { 44 44 + int32 setting = 1; 45 45 + } 46 46 + 47 47 + message SoundMaxResponse { 48 48 + int32 value = 1; 49 49 + } 50 50 + 51 51 + message SoundUnitRequest { } 52 52 + 53 53 + message SoundUnitResponse { } 54 54 + 55 55 + message SoundVal2PhysRequest { 56 56 + int32 setting = 1; 57 57 + int32 value = 2; 58 58 + } 59 59 + 60 60 + message SoundVal2PhysResponse { 61 61 + int32 value = 1; 62 62 + } 63 63 + 64 64 + message GetPitchRequest { } 65 65 + 66 66 + message GetPitchResponse { 67 67 + int32 value = 1; 68 68 + } 69 69 + 70 70 + message SetPitchRequest { 71 71 + int32 value = 1; 72 72 + } 73 73 + 74 74 + message SetPitchResponse { } 75 75 + 76 76 + message BeepPlayRequest { 77 77 + uint32 frequency = 1; 78 78 + uint32 duration = 2; 79 79 + uint32 amplitude = 3; 80 80 + } 81 81 + 82 82 + message BeepPlayResponse { } 83 83 + 84 84 + message PcmbufFadeRequest { 85 85 + int32 fade = 1; 86 86 + bool in = 2; 87 87 + } 88 88 + 89 89 + message PcmbufFadeResponse { } 90 90 + 91 91 + message PcmbufSetLowLatencyRequest { 92 92 + bool state = 1; 93 93 + } 94 94 + 95 95 + message PcmbufSetLowLatencyResponse { } 96 96 + 97 97 + message SystemSoundPlayRequest { 98 98 + uint32 sound = 1; 99 99 + } 100 100 + 101 101 + message SystemSoundPlayResponse { } 102 102 + 103 103 + message KeyclickClickRequest { 104 104 + bool rawbutton = 1; 105 105 + int32 action = 2; 106 106 + } 107 107 + 108 108 + message KeyclickClickResponse { } 109 109 + 110 110 + service SoundService { 111 111 + rpc AdjustVolume(AdjustVolumeRequest) returns (AdjustVolumeResponse); 112 112 + rpc SoundSet(SoundSetRequest) returns (SoundSetResponse); 113 113 + rpc SoundCurrent(SoundCurrentRequest) returns (SoundCurrentResponse); 114 114 + rpc SoundDefault(SoundDefaultRequest) returns (SoundDefaultResponse); 115 115 + rpc SoundMin(SoundMinRequest) returns (SoundMinResponse); 116 116 + rpc SoundMax(SoundMaxRequest) returns (SoundMaxResponse); 117 117 + rpc SoundUnit(SoundUnitRequest) returns (SoundUnitResponse); 118 118 + rpc SoundVal2Phys(SoundVal2PhysRequest) returns (SoundVal2PhysResponse); 119 119 + rpc GetPitch(GetPitchRequest) returns (GetPitchResponse); 120 120 + rpc SetPitch(SetPitchRequest) returns (SetPitchResponse); 121 121 + rpc BeepPlay(BeepPlayRequest) returns (BeepPlayResponse); 122 122 + rpc PcmbufFade(PcmbufFadeRequest) returns (PcmbufFadeResponse); 123 123 + rpc PcmbufSetLowLatency(PcmbufSetLowLatencyRequest) returns (PcmbufSetLowLatencyResponse); 124 124 + rpc SystemSoundPlay(SystemSoundPlayRequest) returns (SystemSoundPlayResponse); 125 125 + rpc KeyclickClick(KeyclickClickRequest) returns (KeyclickClickResponse); 126 126 + }

+31

crates/controls/proto/rockbox/v1alpha1/system.proto

··· 1 1 + syntax = "proto3"; 2 2 + 3 3 + package rockbox.v1alpha1; 4 4 + 5 5 + message GetRockboxVersionRequest { 6 6 + } 7 7 + 8 8 + message GetRockboxVersionResponse { 9 9 + string version = 1; 10 10 + } 11 11 + 12 12 + message GetGlobalStatusRequest { 13 13 + } 14 14 + 15 15 + message GetGlobalStatusResponse { 16 16 + int32 resume_index = 1; 17 17 + uint32 resume_crc32 = 2; 18 18 + uint32 resume_elapsed = 3; 19 19 + uint32 resume_offset = 4; 20 20 + int32 runtime = 5; 21 21 + int32 topruntime = 6; 22 22 + int32 dircache_size = 7; 23 23 + int32 last_screen = 8; 24 24 + int32 viewer_icon_count = 9; 25 25 + int32 last_volume_change = 10; 26 26 + } 27 27 + 28 28 + service SystemService { 29 29 + rpc GetRockboxVersion(GetRockboxVersionRequest) returns (GetRockboxVersionResponse); 30 30 + rpc GetGlobalStatus(GetGlobalStatusRequest) returns (GetGlobalStatusResponse); 31 31 + }

+9144

crates/controls/src/api/rockbox.v1alpha1.rs

··· 1 1 + // This file is @generated by prost-build. 2 2 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 3 3 + pub struct RockboxBrowseRequest {} 4 4 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 5 5 + pub struct RockboxBrowseResponse {} 6 6 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7 7 + pub struct TreeGetContextRequest {} 8 8 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 9 9 + pub struct TreeGetContextResponse {} 10 10 + #[derive(Clone, PartialEq, ::prost::Message)] 11 11 + pub struct TreeGetEntriesRequest { 12 12 + #[prost(string, optional, tag = "1")] 13 13 + pub path: ::core::option::Option<::prost::alloc::string::String>, 14 14 + } 15 15 + #[derive(Clone, PartialEq, ::prost::Message)] 16 16 + pub struct Entry { 17 17 + #[prost(string, tag = "1")] 18 18 + pub name: ::prost::alloc::string::String, 19 19 + #[prost(int32, tag = "2")] 20 20 + pub attr: i32, 21 21 + #[prost(uint32, tag = "3")] 22 22 + pub time_write: u32, 23 23 + #[prost(int32, tag = "4")] 24 24 + pub customaction: i32, 25 25 + } 26 26 + #[derive(Clone, PartialEq, ::prost::Message)] 27 27 + pub struct TreeGetEntriesResponse { 28 28 + #[prost(message, repeated, tag = "1")] 29 29 + pub entries: ::prost::alloc::vec::Vec<Entry>, 30 30 + } 31 31 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 32 32 + pub struct TreeGetEntryAtRequest {} 33 33 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 34 34 + pub struct TreeGetEntryAtResponse {} 35 35 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 36 36 + pub struct BrowseId3Request {} 37 37 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 38 38 + pub struct BrowseId3Response {} 39 39 + /// Generated client implementations. 40 40 + pub mod browse_service_client { 41 41 + #![allow( 42 42 + unused_variables, 43 43 + dead_code, 44 44 + missing_docs, 45 45 + clippy::wildcard_imports, 46 46 + clippy::let_unit_value, 47 47 + )] 48 48 + use tonic::codegen::*; 49 49 + use tonic::codegen::http::Uri; 50 50 + #[derive(Debug, Clone)] 51 51 + pub struct BrowseServiceClient<T> { 52 52 + inner: tonic::client::Grpc<T>, 53 53 + } 54 54 + impl BrowseServiceClient<tonic::transport::Channel> { 55 55 + /// Attempt to create a new client by connecting to a given endpoint. 56 56 + pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error> 57 57 + where 58 58 + D: TryInto<tonic::transport::Endpoint>, 59 59 + D::Error: Into<StdError>, 60 60 + { 61 61 + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; 62 62 + Ok(Self::new(conn)) 63 63 + } 64 64 + } 65 65 + impl<T> BrowseServiceClient<T> 66 66 + where 67 67 + T: tonic::client::GrpcService<tonic::body::BoxBody>, 68 68 + T::Error: Into<StdError>, 69 69 + T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static, 70 70 + <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send, 71 71 + { 72 72 + pub fn new(inner: T) -> Self { 73 73 + let inner = tonic::client::Grpc::new(inner); 74 74 + Self { inner } 75 75 + } 76 76 + pub fn with_origin(inner: T, origin: Uri) -> Self { 77 77 + let inner = tonic::client::Grpc::with_origin(inner, origin); 78 78 + Self { inner } 79 79 + } 80 80 + pub fn with_interceptor<F>( 81 81 + inner: T, 82 82 + interceptor: F, 83 83 + ) -> BrowseServiceClient<InterceptedService<T, F>> 84 84 + where 85 85 + F: tonic::service::Interceptor, 86 86 + T::ResponseBody: Default, 87 87 + T: tonic::codegen::Service< 88 88 + http::Request<tonic::body::BoxBody>, 89 89 + Response = http::Response< 90 90 + <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 91 91 + >, 92 92 + >, 93 93 + <T as tonic::codegen::Service< 94 94 + http::Request<tonic::body::BoxBody>, 95 95 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 96 96 + { 97 97 + BrowseServiceClient::new(InterceptedService::new(inner, interceptor)) 98 98 + } 99 99 + /// Compress requests with the given encoding. 100 100 + /// 101 101 + /// This requires the server to support it otherwise it might respond with an 102 102 + /// error. 103 103 + #[must_use] 104 104 + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { 105 105 + self.inner = self.inner.send_compressed(encoding); 106 106 + self 107 107 + } 108 108 + /// Enable decompressing responses. 109 109 + #[must_use] 110 110 + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { 111 111 + self.inner = self.inner.accept_compressed(encoding); 112 112 + self 113 113 + } 114 114 + /// Limits the maximum size of a decoded message. 115 115 + /// 116 116 + /// Default: `4MB` 117 117 + #[must_use] 118 118 + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { 119 119 + self.inner = self.inner.max_decoding_message_size(limit); 120 120 + self 121 121 + } 122 122 + /// Limits the maximum size of an encoded message. 123 123 + /// 124 124 + /// Default: `usize::MAX` 125 125 + #[must_use] 126 126 + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { 127 127 + self.inner = self.inner.max_encoding_message_size(limit); 128 128 + self 129 129 + } 130 130 + pub async fn tree_get_entries( 131 131 + &mut self, 132 132 + request: impl tonic::IntoRequest<super::TreeGetEntriesRequest>, 133 133 + ) -> std::result::Result< 134 134 + tonic::Response<super::TreeGetEntriesResponse>, 135 135 + tonic::Status, 136 136 + > { 137 137 + self.inner 138 138 + .ready() 139 139 + .await 140 140 + .map_err(|e| { 141 141 + tonic::Status::unknown( 142 142 + format!("Service was not ready: {}", e.into()), 143 143 + ) 144 144 + })?; 145 145 + let codec = tonic::codec::ProstCodec::default(); 146 146 + let path = http::uri::PathAndQuery::from_static( 147 147 + "/rockbox.v1alpha1.BrowseService/TreeGetEntries", 148 148 + ); 149 149 + let mut req = request.into_request(); 150 150 + req.extensions_mut() 151 151 + .insert( 152 152 + GrpcMethod::new("rockbox.v1alpha1.BrowseService", "TreeGetEntries"), 153 153 + ); 154 154 + self.inner.unary(req, path, codec).await 155 155 + } 156 156 + } 157 157 + } 158 158 + /// Generated server implementations. 159 159 + pub mod browse_service_server { 160 160 + #![allow( 161 161 + unused_variables, 162 162 + dead_code, 163 163 + missing_docs, 164 164 + clippy::wildcard_imports, 165 165 + clippy::let_unit_value, 166 166 + )] 167 167 + use tonic::codegen::*; 168 168 + /// Generated trait containing gRPC methods that should be implemented for use with BrowseServiceServer. 169 169 + #[async_trait] 170 170 + pub trait BrowseService: std::marker::Send + std::marker::Sync + 'static { 171 171 + async fn tree_get_entries( 172 172 + &self, 173 173 + request: tonic::Request<super::TreeGetEntriesRequest>, 174 174 + ) -> std::result::Result< 175 175 + tonic::Response<super::TreeGetEntriesResponse>, 176 176 + tonic::Status, 177 177 + >; 178 178 + } 179 179 + #[derive(Debug)] 180 180 + pub struct BrowseServiceServer<T> { 181 181 + inner: Arc<T>, 182 182 + accept_compression_encodings: EnabledCompressionEncodings, 183 183 + send_compression_encodings: EnabledCompressionEncodings, 184 184 + max_decoding_message_size: Option<usize>, 185 185 + max_encoding_message_size: Option<usize>, 186 186 + } 187 187 + impl<T> BrowseServiceServer<T> { 188 188 + pub fn new(inner: T) -> Self { 189 189 + Self::from_arc(Arc::new(inner)) 190 190 + } 191 191 + pub fn from_arc(inner: Arc<T>) -> Self { 192 192 + Self { 193 193 + inner, 194 194 + accept_compression_encodings: Default::default(), 195 195 + send_compression_encodings: Default::default(), 196 196 + max_decoding_message_size: None, 197 197 + max_encoding_message_size: None, 198 198 + } 199 199 + } 200 200 + pub fn with_interceptor<F>( 201 201 + inner: T, 202 202 + interceptor: F, 203 203 + ) -> InterceptedService<Self, F> 204 204 + where 205 205 + F: tonic::service::Interceptor, 206 206 + { 207 207 + InterceptedService::new(Self::new(inner), interceptor) 208 208 + } 209 209 + /// Enable decompressing requests with the given encoding. 210 210 + #[must_use] 211 211 + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { 212 212 + self.accept_compression_encodings.enable(encoding); 213 213 + self 214 214 + } 215 215 + /// Compress responses with the given encoding, if the client supports it. 216 216 + #[must_use] 217 217 + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { 218 218 + self.send_compression_encodings.enable(encoding); 219 219 + self 220 220 + } 221 221 + /// Limits the maximum size of a decoded message. 222 222 + /// 223 223 + /// Default: `4MB` 224 224 + #[must_use] 225 225 + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { 226 226 + self.max_decoding_message_size = Some(limit); 227 227 + self 228 228 + } 229 229 + /// Limits the maximum size of an encoded message. 230 230 + /// 231 231 + /// Default: `usize::MAX` 232 232 + #[must_use] 233 233 + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { 234 234 + self.max_encoding_message_size = Some(limit); 235 235 + self 236 236 + } 237 237 + } 238 238 + impl<T, B> tonic::codegen::Service<http::Request<B>> for BrowseServiceServer<T> 239 239 + where 240 240 + T: BrowseService, 241 241 + B: Body + std::marker::Send + 'static, 242 242 + B::Error: Into<StdError> + std::marker::Send + 'static, 243 243 + { 244 244 + type Response = http::Response<tonic::body::BoxBody>; 245 245 + type Error = std::convert::Infallible; 246 246 + type Future = BoxFuture<Self::Response, Self::Error>; 247 247 + fn poll_ready( 248 248 + &mut self, 249 249 + _cx: &mut Context<'_>, 250 250 + ) -> Poll<std::result::Result<(), Self::Error>> { 251 251 + Poll::Ready(Ok(())) 252 252 + } 253 253 + fn call(&mut self, req: http::Request<B>) -> Self::Future { 254 254 + match req.uri().path() { 255 255 + "/rockbox.v1alpha1.BrowseService/TreeGetEntries" => { 256 256 + #[allow(non_camel_case_types)] 257 257 + struct TreeGetEntriesSvc<T: BrowseService>(pub Arc<T>); 258 258 + impl< 259 259 + T: BrowseService, 260 260 + > tonic::server::UnaryService<super::TreeGetEntriesRequest> 261 261 + for TreeGetEntriesSvc<T> { 262 262 + type Response = super::TreeGetEntriesResponse; 263 263 + type Future = BoxFuture< 264 264 + tonic::Response<Self::Response>, 265 265 + tonic::Status, 266 266 + >; 267 267 + fn call( 268 268 + &mut self, 269 269 + request: tonic::Request<super::TreeGetEntriesRequest>, 270 270 + ) -> Self::Future { 271 271 + let inner = Arc::clone(&self.0); 272 272 + let fut = async move { 273 273 + <T as BrowseService>::tree_get_entries(&inner, request) 274 274 + .await 275 275 + }; 276 276 + Box::pin(fut) 277 277 + } 278 278 + } 279 279 + let accept_compression_encodings = self.accept_compression_encodings; 280 280 + let send_compression_encodings = self.send_compression_encodings; 281 281 + let max_decoding_message_size = self.max_decoding_message_size; 282 282 + let max_encoding_message_size = self.max_encoding_message_size; 283 283 + let inner = self.inner.clone(); 284 284 + let fut = async move { 285 285 + let method = TreeGetEntriesSvc(inner); 286 286 + let codec = tonic::codec::ProstCodec::default(); 287 287 + let mut grpc = tonic::server::Grpc::new(codec) 288 288 + .apply_compression_config( 289 289 + accept_compression_encodings, 290 290 + send_compression_encodings, 291 291 + ) 292 292 + .apply_max_message_size_config( 293 293 + max_decoding_message_size, 294 294 + max_encoding_message_size, 295 295 + ); 296 296 + let res = grpc.unary(method, req).await; 297 297 + Ok(res) 298 298 + }; 299 299 + Box::pin(fut) 300 300 + } 301 301 + _ => { 302 302 + Box::pin(async move { 303 303 + let mut response = http::Response::new(empty_body()); 304 304 + let headers = response.headers_mut(); 305 305 + headers 306 306 + .insert( 307 307 + tonic::Status::GRPC_STATUS, 308 308 + (tonic::Code::Unimplemented as i32).into(), 309 309 + ); 310 310 + headers 311 311 + .insert( 312 312 + http::header::CONTENT_TYPE, 313 313 + tonic::metadata::GRPC_CONTENT_TYPE, 314 314 + ); 315 315 + Ok(response) 316 316 + }) 317 317 + } 318 318 + } 319 319 + } 320 320 + } 321 321 + impl<T> Clone for BrowseServiceServer<T> { 322 322 + fn clone(&self) -> Self { 323 323 + let inner = self.inner.clone(); 324 324 + Self { 325 325 + inner, 326 326 + accept_compression_encodings: self.accept_compression_encodings, 327 327 + send_compression_encodings: self.send_compression_encodings, 328 328 + max_decoding_message_size: self.max_decoding_message_size, 329 329 + max_encoding_message_size: self.max_encoding_message_size, 330 330 + } 331 331 + } 332 332 + } 333 333 + /// Generated gRPC service name 334 334 + pub const SERVICE_NAME: &str = "rockbox.v1alpha1.BrowseService"; 335 335 + impl<T> tonic::server::NamedService for BrowseServiceServer<T> { 336 336 + const NAME: &'static str = SERVICE_NAME; 337 337 + } 338 338 + } 339 339 + #[derive(Clone, PartialEq, ::prost::Message)] 340 340 + pub struct Track { 341 341 + #[prost(string, tag = "1")] 342 342 + pub id: ::prost::alloc::string::String, 343 343 + #[prost(string, tag = "2")] 344 344 + pub path: ::prost::alloc::string::String, 345 345 + #[prost(string, tag = "3")] 346 346 + pub title: ::prost::alloc::string::String, 347 347 + #[prost(string, tag = "4")] 348 348 + pub artist: ::prost::alloc::string::String, 349 349 + #[prost(string, tag = "5")] 350 350 + pub album: ::prost::alloc::string::String, 351 351 + #[prost(string, tag = "6")] 352 352 + pub album_artist: ::prost::alloc::string::String, 353 353 + #[prost(uint32, tag = "7")] 354 354 + pub bitrate: u32, 355 355 + #[prost(string, tag = "8")] 356 356 + pub composer: ::prost::alloc::string::String, 357 357 + #[prost(uint32, tag = "9")] 358 358 + pub disc_number: u32, 359 359 + #[prost(uint32, tag = "10")] 360 360 + pub filesize: u32, 361 361 + #[prost(uint32, tag = "11")] 362 362 + pub frequency: u32, 363 363 + #[prost(uint32, tag = "12")] 364 364 + pub length: u32, 365 365 + #[prost(uint32, tag = "13")] 366 366 + pub track_number: u32, 367 367 + #[prost(uint32, tag = "14")] 368 368 + pub year: u32, 369 369 + #[prost(string, tag = "15")] 370 370 + pub year_string: ::prost::alloc::string::String, 371 371 + #[prost(string, tag = "16")] 372 372 + pub genre: ::prost::alloc::string::String, 373 373 + #[prost(string, tag = "17")] 374 374 + pub md5: ::prost::alloc::string::String, 375 375 + #[prost(string, optional, tag = "18")] 376 376 + pub album_art: ::core::option::Option<::prost::alloc::string::String>, 377 377 + #[prost(string, optional, tag = "19")] 378 378 + pub artist_id: ::core::option::Option<::prost::alloc::string::String>, 379 379 + #[prost(string, optional, tag = "20")] 380 380 + pub album_id: ::core::option::Option<::prost::alloc::string::String>, 381 381 + #[prost(string, optional, tag = "21")] 382 382 + pub genre_id: ::core::option::Option<::prost::alloc::string::String>, 383 383 + #[prost(string, tag = "22")] 384 384 + pub created_at: ::prost::alloc::string::String, 385 385 + #[prost(string, tag = "23")] 386 386 + pub updated_at: ::prost::alloc::string::String, 387 387 + } 388 388 + #[derive(Clone, PartialEq, ::prost::Message)] 389 389 + pub struct Artist { 390 390 + #[prost(string, tag = "1")] 391 391 + pub id: ::prost::alloc::string::String, 392 392 + #[prost(string, tag = "2")] 393 393 + pub name: ::prost::alloc::string::String, 394 394 + #[prost(string, optional, tag = "3")] 395 395 + pub bio: ::core::option::Option<::prost::alloc::string::String>, 396 396 + #[prost(string, optional, tag = "4")] 397 397 + pub image: ::core::option::Option<::prost::alloc::string::String>, 398 398 + #[prost(message, repeated, tag = "5")] 399 399 + pub albums: ::prost::alloc::vec::Vec<Album>, 400 400 + #[prost(message, repeated, tag = "6")] 401 401 + pub tracks: ::prost::alloc::vec::Vec<Track>, 402 402 + } 403 403 + #[derive(Clone, PartialEq, ::prost::Message)] 404 404 + pub struct Album { 405 405 + #[prost(string, tag = "1")] 406 406 + pub id: ::prost::alloc::string::String, 407 407 + #[prost(string, tag = "2")] 408 408 + pub title: ::prost::alloc::string::String, 409 409 + #[prost(string, tag = "3")] 410 410 + pub artist: ::prost::alloc::string::String, 411 411 + #[prost(uint32, tag = "4")] 412 412 + pub year: u32, 413 413 + #[prost(string, tag = "5")] 414 414 + pub year_string: ::prost::alloc::string::String, 415 415 + #[prost(string, optional, tag = "6")] 416 416 + pub album_art: ::core::option::Option<::prost::alloc::string::String>, 417 417 + #[prost(string, tag = "7")] 418 418 + pub md5: ::prost::alloc::string::String, 419 419 + #[prost(string, tag = "8")] 420 420 + pub artist_id: ::prost::alloc::string::String, 421 421 + #[prost(message, repeated, tag = "9")] 422 422 + pub tracks: ::prost::alloc::vec::Vec<Track>, 423 423 + } 424 424 + #[derive(Clone, PartialEq, ::prost::Message)] 425 425 + pub struct GetAlbumRequest { 426 426 + #[prost(string, tag = "1")] 427 427 + pub id: ::prost::alloc::string::String, 428 428 + } 429 429 + #[derive(Clone, PartialEq, ::prost::Message)] 430 430 + pub struct GetAlbumResponse { 431 431 + #[prost(message, optional, tag = "1")] 432 432 + pub album: ::core::option::Option<Album>, 433 433 + } 434 434 + #[derive(Clone, PartialEq, ::prost::Message)] 435 435 + pub struct GetArtistRequest { 436 436 + #[prost(string, tag = "1")] 437 437 + pub id: ::prost::alloc::string::String, 438 438 + } 439 439 + #[derive(Clone, PartialEq, ::prost::Message)] 440 440 + pub struct GetArtistResponse { 441 441 + #[prost(message, optional, tag = "1")] 442 442 + pub artist: ::core::option::Option<Artist>, 443 443 + } 444 444 + #[derive(Clone, PartialEq, ::prost::Message)] 445 445 + pub struct GetTrackRequest { 446 446 + #[prost(string, tag = "1")] 447 447 + pub id: ::prost::alloc::string::String, 448 448 + } 449 449 + #[derive(Clone, PartialEq, ::prost::Message)] 450 450 + pub struct GetTrackResponse { 451 451 + #[prost(message, optional, tag = "1")] 452 452 + pub track: ::core::option::Option<Track>, 453 453 + } 454 454 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 455 455 + pub struct GetAlbumsRequest {} 456 456 + #[derive(Clone, PartialEq, ::prost::Message)] 457 457 + pub struct GetAlbumsResponse { 458 458 + #[prost(message, repeated, tag = "1")] 459 459 + pub albums: ::prost::alloc::vec::Vec<Album>, 460 460 + } 461 461 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 462 462 + pub struct GetArtistsRequest {} 463 463 + #[derive(Clone, PartialEq, ::prost::Message)] 464 464 + pub struct GetArtistsResponse { 465 465 + #[prost(message, repeated, tag = "1")] 466 466 + pub artists: ::prost::alloc::vec::Vec<Artist>, 467 467 + } 468 468 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 469 469 + pub struct GetTracksRequest {} 470 470 + #[derive(Clone, PartialEq, ::prost::Message)] 471 471 + pub struct GetTracksResponse { 472 472 + #[prost(message, repeated, tag = "1")] 473 473 + pub tracks: ::prost::alloc::vec::Vec<Track>, 474 474 + } 475 475 + #[derive(Clone, PartialEq, ::prost::Message)] 476 476 + pub struct LikeTrackRequest { 477 477 + #[prost(string, tag = "1")] 478 478 + pub id: ::prost::alloc::string::String, 479 479 + } 480 480 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 481 481 + pub struct LikeTrackResponse {} 482 482 + #[derive(Clone, PartialEq, ::prost::Message)] 483 483 + pub struct LikeAlbumRequest { 484 484 + #[prost(string, tag = "1")] 485 485 + pub id: ::prost::alloc::string::String, 486 486 + } 487 487 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 488 488 + pub struct LikeAlbumResponse {} 489 489 + #[derive(Clone, PartialEq, ::prost::Message)] 490 490 + pub struct UnlikeTrackRequest { 491 491 + #[prost(string, tag = "1")] 492 492 + pub id: ::prost::alloc::string::String, 493 493 + } 494 494 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 495 495 + pub struct UnlikeTrackResponse {} 496 496 + #[derive(Clone, PartialEq, ::prost::Message)] 497 497 + pub struct UnlikeAlbumRequest { 498 498 + #[prost(string, tag = "1")] 499 499 + pub id: ::prost::alloc::string::String, 500 500 + } 501 501 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 502 502 + pub struct UnlikeAlbumResponse {} 503 503 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 504 504 + pub struct GetLikedTracksRequest {} 505 505 + #[derive(Clone, PartialEq, ::prost::Message)] 506 506 + pub struct GetLikedTracksResponse { 507 507 + #[prost(message, repeated, tag = "1")] 508 508 + pub tracks: ::prost::alloc::vec::Vec<Track>, 509 509 + } 510 510 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 511 511 + pub struct GetLikedAlbumsRequest {} 512 512 + #[derive(Clone, PartialEq, ::prost::Message)] 513 513 + pub struct GetLikedAlbumsResponse { 514 514 + #[prost(message, repeated, tag = "1")] 515 515 + pub albums: ::prost::alloc::vec::Vec<Album>, 516 516 + } 517 517 + #[derive(Clone, PartialEq, ::prost::Message)] 518 518 + pub struct ScanLibraryRequest { 519 519 + #[prost(string, optional, tag = "1")] 520 520 + pub path: ::core::option::Option<::prost::alloc::string::String>, 521 521 + } 522 522 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 523 523 + pub struct ScanLibraryResponse {} 524 524 + #[derive(Clone, PartialEq, ::prost::Message)] 525 525 + pub struct SearchRequest { 526 526 + #[prost(string, tag = "1")] 527 527 + pub term: ::prost::alloc::string::String, 528 528 + } 529 529 + #[derive(Clone, PartialEq, ::prost::Message)] 530 530 + pub struct SearchResponse { 531 531 + #[prost(message, repeated, tag = "1")] 532 532 + pub tracks: ::prost::alloc::vec::Vec<Track>, 533 533 + #[prost(message, repeated, tag = "2")] 534 534 + pub albums: ::prost::alloc::vec::Vec<Album>, 535 535 + #[prost(message, repeated, tag = "3")] 536 536 + pub artists: ::prost::alloc::vec::Vec<Artist>, 537 537 + } 538 538 + /// Generated client implementations. 539 539 + pub mod library_service_client { 540 540 + #![allow( 541 541 + unused_variables, 542 542 + dead_code, 543 543 + missing_docs, 544 544 + clippy::wildcard_imports, 545 545 + clippy::let_unit_value, 546 546 + )] 547 547 + use tonic::codegen::*; 548 548 + use tonic::codegen::http::Uri; 549 549 + #[derive(Debug, Clone)] 550 550 + pub struct LibraryServiceClient<T> { 551 551 + inner: tonic::client::Grpc<T>, 552 552 + } 553 553 + impl LibraryServiceClient<tonic::transport::Channel> { 554 554 + /// Attempt to create a new client by connecting to a given endpoint. 555 555 + pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error> 556 556 + where 557 557 + D: TryInto<tonic::transport::Endpoint>, 558 558 + D::Error: Into<StdError>, 559 559 + { 560 560 + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; 561 561 + Ok(Self::new(conn)) 562 562 + } 563 563 + } 564 564 + impl<T> LibraryServiceClient<T> 565 565 + where 566 566 + T: tonic::client::GrpcService<tonic::body::BoxBody>, 567 567 + T::Error: Into<StdError>, 568 568 + T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static, 569 569 + <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send, 570 570 + { 571 571 + pub fn new(inner: T) -> Self { 572 572 + let inner = tonic::client::Grpc::new(inner); 573 573 + Self { inner } 574 574 + } 575 575 + pub fn with_origin(inner: T, origin: Uri) -> Self { 576 576 + let inner = tonic::client::Grpc::with_origin(inner, origin); 577 577 + Self { inner } 578 578 + } 579 579 + pub fn with_interceptor<F>( 580 580 + inner: T, 581 581 + interceptor: F, 582 582 + ) -> LibraryServiceClient<InterceptedService<T, F>> 583 583 + where 584 584 + F: tonic::service::Interceptor, 585 585 + T::ResponseBody: Default, 586 586 + T: tonic::codegen::Service< 587 587 + http::Request<tonic::body::BoxBody>, 588 588 + Response = http::Response< 589 589 + <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 590 590 + >, 591 591 + >, 592 592 + <T as tonic::codegen::Service< 593 593 + http::Request<tonic::body::BoxBody>, 594 594 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 595 595 + { 596 596 + LibraryServiceClient::new(InterceptedService::new(inner, interceptor)) 597 597 + } 598 598 + /// Compress requests with the given encoding. 599 599 + /// 600 600 + /// This requires the server to support it otherwise it might respond with an 601 601 + /// error. 602 602 + #[must_use] 603 603 + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { 604 604 + self.inner = self.inner.send_compressed(encoding); 605 605 + self 606 606 + } 607 607 + /// Enable decompressing responses. 608 608 + #[must_use] 609 609 + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { 610 610 + self.inner = self.inner.accept_compressed(encoding); 611 611 + self 612 612 + } 613 613 + /// Limits the maximum size of a decoded message. 614 614 + /// 615 615 + /// Default: `4MB` 616 616 + #[must_use] 617 617 + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { 618 618 + self.inner = self.inner.max_decoding_message_size(limit); 619 619 + self 620 620 + } 621 621 + /// Limits the maximum size of an encoded message. 622 622 + /// 623 623 + /// Default: `usize::MAX` 624 624 + #[must_use] 625 625 + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { 626 626 + self.inner = self.inner.max_encoding_message_size(limit); 627 627 + self 628 628 + } 629 629 + pub async fn get_albums( 630 630 + &mut self, 631 631 + request: impl tonic::IntoRequest<super::GetAlbumsRequest>, 632 632 + ) -> std::result::Result< 633 633 + tonic::Response<super::GetAlbumsResponse>, 634 634 + tonic::Status, 635 635 + > { 636 636 + self.inner 637 637 + .ready() 638 638 + .await 639 639 + .map_err(|e| { 640 640 + tonic::Status::unknown( 641 641 + format!("Service was not ready: {}", e.into()), 642 642 + ) 643 643 + })?; 644 644 + let codec = tonic::codec::ProstCodec::default(); 645 645 + let path = http::uri::PathAndQuery::from_static( 646 646 + "/rockbox.v1alpha1.LibraryService/GetAlbums", 647 647 + ); 648 648 + let mut req = request.into_request(); 649 649 + req.extensions_mut() 650 650 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbums")); 651 651 + self.inner.unary(req, path, codec).await 652 652 + } 653 653 + pub async fn get_artists( 654 654 + &mut self, 655 655 + request: impl tonic::IntoRequest<super::GetArtistsRequest>, 656 656 + ) -> std::result::Result< 657 657 + tonic::Response<super::GetArtistsResponse>, 658 658 + tonic::Status, 659 659 + > { 660 660 + self.inner 661 661 + .ready() 662 662 + .await 663 663 + .map_err(|e| { 664 664 + tonic::Status::unknown( 665 665 + format!("Service was not ready: {}", e.into()), 666 666 + ) 667 667 + })?; 668 668 + let codec = tonic::codec::ProstCodec::default(); 669 669 + let path = http::uri::PathAndQuery::from_static( 670 670 + "/rockbox.v1alpha1.LibraryService/GetArtists", 671 671 + ); 672 672 + let mut req = request.into_request(); 673 673 + req.extensions_mut() 674 674 + .insert( 675 675 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtists"), 676 676 + ); 677 677 + self.inner.unary(req, path, codec).await 678 678 + } 679 679 + pub async fn get_tracks( 680 680 + &mut self, 681 681 + request: impl tonic::IntoRequest<super::GetTracksRequest>, 682 682 + ) -> std::result::Result< 683 683 + tonic::Response<super::GetTracksResponse>, 684 684 + tonic::Status, 685 685 + > { 686 686 + self.inner 687 687 + .ready() 688 688 + .await 689 689 + .map_err(|e| { 690 690 + tonic::Status::unknown( 691 691 + format!("Service was not ready: {}", e.into()), 692 692 + ) 693 693 + })?; 694 694 + let codec = tonic::codec::ProstCodec::default(); 695 695 + let path = http::uri::PathAndQuery::from_static( 696 696 + "/rockbox.v1alpha1.LibraryService/GetTracks", 697 697 + ); 698 698 + let mut req = request.into_request(); 699 699 + req.extensions_mut() 700 700 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTracks")); 701 701 + self.inner.unary(req, path, codec).await 702 702 + } 703 703 + pub async fn get_album( 704 704 + &mut self, 705 705 + request: impl tonic::IntoRequest<super::GetAlbumRequest>, 706 706 + ) -> std::result::Result< 707 707 + tonic::Response<super::GetAlbumResponse>, 708 708 + tonic::Status, 709 709 + > { 710 710 + self.inner 711 711 + .ready() 712 712 + .await 713 713 + .map_err(|e| { 714 714 + tonic::Status::unknown( 715 715 + format!("Service was not ready: {}", e.into()), 716 716 + ) 717 717 + })?; 718 718 + let codec = tonic::codec::ProstCodec::default(); 719 719 + let path = http::uri::PathAndQuery::from_static( 720 720 + "/rockbox.v1alpha1.LibraryService/GetAlbum", 721 721 + ); 722 722 + let mut req = request.into_request(); 723 723 + req.extensions_mut() 724 724 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbum")); 725 725 + self.inner.unary(req, path, codec).await 726 726 + } 727 727 + pub async fn get_artist( 728 728 + &mut self, 729 729 + request: impl tonic::IntoRequest<super::GetArtistRequest>, 730 730 + ) -> std::result::Result< 731 731 + tonic::Response<super::GetArtistResponse>, 732 732 + tonic::Status, 733 733 + > { 734 734 + self.inner 735 735 + .ready() 736 736 + .await 737 737 + .map_err(|e| { 738 738 + tonic::Status::unknown( 739 739 + format!("Service was not ready: {}", e.into()), 740 740 + ) 741 741 + })?; 742 742 + let codec = tonic::codec::ProstCodec::default(); 743 743 + let path = http::uri::PathAndQuery::from_static( 744 744 + "/rockbox.v1alpha1.LibraryService/GetArtist", 745 745 + ); 746 746 + let mut req = request.into_request(); 747 747 + req.extensions_mut() 748 748 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtist")); 749 749 + self.inner.unary(req, path, codec).await 750 750 + } 751 751 + pub async fn get_track( 752 752 + &mut self, 753 753 + request: impl tonic::IntoRequest<super::GetTrackRequest>, 754 754 + ) -> std::result::Result< 755 755 + tonic::Response<super::GetTrackResponse>, 756 756 + tonic::Status, 757 757 + > { 758 758 + self.inner 759 759 + .ready() 760 760 + .await 761 761 + .map_err(|e| { 762 762 + tonic::Status::unknown( 763 763 + format!("Service was not ready: {}", e.into()), 764 764 + ) 765 765 + })?; 766 766 + let codec = tonic::codec::ProstCodec::default(); 767 767 + let path = http::uri::PathAndQuery::from_static( 768 768 + "/rockbox.v1alpha1.LibraryService/GetTrack", 769 769 + ); 770 770 + let mut req = request.into_request(); 771 771 + req.extensions_mut() 772 772 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTrack")); 773 773 + self.inner.unary(req, path, codec).await 774 774 + } 775 775 + pub async fn like_track( 776 776 + &mut self, 777 777 + request: impl tonic::IntoRequest<super::LikeTrackRequest>, 778 778 + ) -> std::result::Result< 779 779 + tonic::Response<super::LikeTrackResponse>, 780 780 + tonic::Status, 781 781 + > { 782 782 + self.inner 783 783 + .ready() 784 784 + .await 785 785 + .map_err(|e| { 786 786 + tonic::Status::unknown( 787 787 + format!("Service was not ready: {}", e.into()), 788 788 + ) 789 789 + })?; 790 790 + let codec = tonic::codec::ProstCodec::default(); 791 791 + let path = http::uri::PathAndQuery::from_static( 792 792 + "/rockbox.v1alpha1.LibraryService/LikeTrack", 793 793 + ); 794 794 + let mut req = request.into_request(); 795 795 + req.extensions_mut() 796 796 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeTrack")); 797 797 + self.inner.unary(req, path, codec).await 798 798 + } 799 799 + pub async fn unlike_track( 800 800 + &mut self, 801 801 + request: impl tonic::IntoRequest<super::UnlikeTrackRequest>, 802 802 + ) -> std::result::Result< 803 803 + tonic::Response<super::UnlikeTrackResponse>, 804 804 + tonic::Status, 805 805 + > { 806 806 + self.inner 807 807 + .ready() 808 808 + .await 809 809 + .map_err(|e| { 810 810 + tonic::Status::unknown( 811 811 + format!("Service was not ready: {}", e.into()), 812 812 + ) 813 813 + })?; 814 814 + let codec = tonic::codec::ProstCodec::default(); 815 815 + let path = http::uri::PathAndQuery::from_static( 816 816 + "/rockbox.v1alpha1.LibraryService/UnlikeTrack", 817 817 + ); 818 818 + let mut req = request.into_request(); 819 819 + req.extensions_mut() 820 820 + .insert( 821 821 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeTrack"), 822 822 + ); 823 823 + self.inner.unary(req, path, codec).await 824 824 + } 825 825 + pub async fn like_album( 826 826 + &mut self, 827 827 + request: impl tonic::IntoRequest<super::LikeAlbumRequest>, 828 828 + ) -> std::result::Result< 829 829 + tonic::Response<super::LikeAlbumResponse>, 830 830 + tonic::Status, 831 831 + > { 832 832 + self.inner 833 833 + .ready() 834 834 + .await 835 835 + .map_err(|e| { 836 836 + tonic::Status::unknown( 837 837 + format!("Service was not ready: {}", e.into()), 838 838 + ) 839 839 + })?; 840 840 + let codec = tonic::codec::ProstCodec::default(); 841 841 + let path = http::uri::PathAndQuery::from_static( 842 842 + "/rockbox.v1alpha1.LibraryService/LikeAlbum", 843 843 + ); 844 844 + let mut req = request.into_request(); 845 845 + req.extensions_mut() 846 846 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeAlbum")); 847 847 + self.inner.unary(req, path, codec).await 848 848 + } 849 849 + pub async fn unlike_album( 850 850 + &mut self, 851 851 + request: impl tonic::IntoRequest<super::UnlikeAlbumRequest>, 852 852 + ) -> std::result::Result< 853 853 + tonic::Response<super::UnlikeAlbumResponse>, 854 854 + tonic::Status, 855 855 + > { 856 856 + self.inner 857 857 + .ready() 858 858 + .await 859 859 + .map_err(|e| { 860 860 + tonic::Status::unknown( 861 861 + format!("Service was not ready: {}", e.into()), 862 862 + ) 863 863 + })?; 864 864 + let codec = tonic::codec::ProstCodec::default(); 865 865 + let path = http::uri::PathAndQuery::from_static( 866 866 + "/rockbox.v1alpha1.LibraryService/UnlikeAlbum", 867 867 + ); 868 868 + let mut req = request.into_request(); 869 869 + req.extensions_mut() 870 870 + .insert( 871 871 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeAlbum"), 872 872 + ); 873 873 + self.inner.unary(req, path, codec).await 874 874 + } 875 875 + pub async fn get_liked_tracks( 876 876 + &mut self, 877 877 + request: impl tonic::IntoRequest<super::GetLikedTracksRequest>, 878 878 + ) -> std::result::Result< 879 879 + tonic::Response<super::GetLikedTracksResponse>, 880 880 + tonic::Status, 881 881 + > { 882 882 + self.inner 883 883 + .ready() 884 884 + .await 885 885 + .map_err(|e| { 886 886 + tonic::Status::unknown( 887 887 + format!("Service was not ready: {}", e.into()), 888 888 + ) 889 889 + })?; 890 890 + let codec = tonic::codec::ProstCodec::default(); 891 891 + let path = http::uri::PathAndQuery::from_static( 892 892 + "/rockbox.v1alpha1.LibraryService/GetLikedTracks", 893 893 + ); 894 894 + let mut req = request.into_request(); 895 895 + req.extensions_mut() 896 896 + .insert( 897 897 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedTracks"), 898 898 + ); 899 899 + self.inner.unary(req, path, codec).await 900 900 + } 901 901 + pub async fn get_liked_albums( 902 902 + &mut self, 903 903 + request: impl tonic::IntoRequest<super::GetLikedAlbumsRequest>, 904 904 + ) -> std::result::Result< 905 905 + tonic::Response<super::GetLikedAlbumsResponse>, 906 906 + tonic::Status, 907 907 + > { 908 908 + self.inner 909 909 + .ready() 910 910 + .await 911 911 + .map_err(|e| { 912 912 + tonic::Status::unknown( 913 913 + format!("Service was not ready: {}", e.into()), 914 914 + ) 915 915 + })?; 916 916 + let codec = tonic::codec::ProstCodec::default(); 917 917 + let path = http::uri::PathAndQuery::from_static( 918 918 + "/rockbox.v1alpha1.LibraryService/GetLikedAlbums", 919 919 + ); 920 920 + let mut req = request.into_request(); 921 921 + req.extensions_mut() 922 922 + .insert( 923 923 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedAlbums"), 924 924 + ); 925 925 + self.inner.unary(req, path, codec).await 926 926 + } 927 927 + pub async fn scan_library( 928 928 + &mut self, 929 929 + request: impl tonic::IntoRequest<super::ScanLibraryRequest>, 930 930 + ) -> std::result::Result< 931 931 + tonic::Response<super::ScanLibraryResponse>, 932 932 + tonic::Status, 933 933 + > { 934 934 + self.inner 935 935 + .ready() 936 936 + .await 937 937 + .map_err(|e| { 938 938 + tonic::Status::unknown( 939 939 + format!("Service was not ready: {}", e.into()), 940 940 + ) 941 941 + })?; 942 942 + let codec = tonic::codec::ProstCodec::default(); 943 943 + let path = http::uri::PathAndQuery::from_static( 944 944 + "/rockbox.v1alpha1.LibraryService/ScanLibrary", 945 945 + ); 946 946 + let mut req = request.into_request(); 947 947 + req.extensions_mut() 948 948 + .insert( 949 949 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "ScanLibrary"), 950 950 + ); 951 951 + self.inner.unary(req, path, codec).await 952 952 + } 953 953 + pub async fn search( 954 954 + &mut self, 955 955 + request: impl tonic::IntoRequest<super::SearchRequest>, 956 956 + ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> { 957 957 + self.inner 958 958 + .ready() 959 959 + .await 960 960 + .map_err(|e| { 961 961 + tonic::Status::unknown( 962 962 + format!("Service was not ready: {}", e.into()), 963 963 + ) 964 964 + })?; 965 965 + let codec = tonic::codec::ProstCodec::default(); 966 966 + let path = http::uri::PathAndQuery::from_static( 967 967 + "/rockbox.v1alpha1.LibraryService/Search", 968 968 + ); 969 969 + let mut req = request.into_request(); 970 970 + req.extensions_mut() 971 971 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "Search")); 972 972 + self.inner.unary(req, path, codec).await 973 973 + } 974 974 + } 975 975 + } 976 976 + /// Generated server implementations. 977 977 + pub mod library_service_server { 978 978 + #![allow( 979 979 + unused_variables, 980 980 + dead_code, 981 981 + missing_docs, 982 982 + clippy::wildcard_imports, 983 983 + clippy::let_unit_value, 984 984 + )] 985 985 + use tonic::codegen::*; 986 986 + /// Generated trait containing gRPC methods that should be implemented for use with LibraryServiceServer. 987 987 + #[async_trait] 988 988 + pub trait LibraryService: std::marker::Send + std::marker::Sync + 'static { 989 989 + async fn get_albums( 990 990 + &self, 991 991 + request: tonic::Request<super::GetAlbumsRequest>, 992 992 + ) -> std::result::Result< 993 993 + tonic::Response<super::GetAlbumsResponse>, 994 994 + tonic::Status, 995 995 + >; 996 996 + async fn get_artists( 997 997 + &self, 998 998 + request: tonic::Request<super::GetArtistsRequest>, 999 999 + ) -> std::result::Result< 1000 1000 + tonic::Response<super::GetArtistsResponse>, 1001 1001 + tonic::Status, 1002 1002 + >; 1003 1003 + async fn get_tracks( 1004 1004 + &self, 1005 1005 + request: tonic::Request<super::GetTracksRequest>, 1006 1006 + ) -> std::result::Result< 1007 1007 + tonic::Response<super::GetTracksResponse>, 1008 1008 + tonic::Status, 1009 1009 + >; 1010 1010 + async fn get_album( 1011 1011 + &self, 1012 1012 + request: tonic::Request<super::GetAlbumRequest>, 1013 1013 + ) -> std::result::Result< 1014 1014 + tonic::Response<super::GetAlbumResponse>, 1015 1015 + tonic::Status, 1016 1016 + >; 1017 1017 + async fn get_artist( 1018 1018 + &self, 1019 1019 + request: tonic::Request<super::GetArtistRequest>, 1020 1020 + ) -> std::result::Result< 1021 1021 + tonic::Response<super::GetArtistResponse>, 1022 1022 + tonic::Status, 1023 1023 + >; 1024 1024 + async fn get_track( 1025 1025 + &self, 1026 1026 + request: tonic::Request<super::GetTrackRequest>, 1027 1027 + ) -> std::result::Result< 1028 1028 + tonic::Response<super::GetTrackResponse>, 1029 1029 + tonic::Status, 1030 1030 + >; 1031 1031 + async fn like_track( 1032 1032 + &self, 1033 1033 + request: tonic::Request<super::LikeTrackRequest>, 1034 1034 + ) -> std::result::Result< 1035 1035 + tonic::Response<super::LikeTrackResponse>, 1036 1036 + tonic::Status, 1037 1037 + >; 1038 1038 + async fn unlike_track( 1039 1039 + &self, 1040 1040 + request: tonic::Request<super::UnlikeTrackRequest>, 1041 1041 + ) -> std::result::Result< 1042 1042 + tonic::Response<super::UnlikeTrackResponse>, 1043 1043 + tonic::Status, 1044 1044 + >; 1045 1045 + async fn like_album( 1046 1046 + &self, 1047 1047 + request: tonic::Request<super::LikeAlbumRequest>, 1048 1048 + ) -> std::result::Result< 1049 1049 + tonic::Response<super::LikeAlbumResponse>, 1050 1050 + tonic::Status, 1051 1051 + >; 1052 1052 + async fn unlike_album( 1053 1053 + &self, 1054 1054 + request: tonic::Request<super::UnlikeAlbumRequest>, 1055 1055 + ) -> std::result::Result< 1056 1056 + tonic::Response<super::UnlikeAlbumResponse>, 1057 1057 + tonic::Status, 1058 1058 + >; 1059 1059 + async fn get_liked_tracks( 1060 1060 + &self, 1061 1061 + request: tonic::Request<super::GetLikedTracksRequest>, 1062 1062 + ) -> std::result::Result< 1063 1063 + tonic::Response<super::GetLikedTracksResponse>, 1064 1064 + tonic::Status, 1065 1065 + >; 1066 1066 + async fn get_liked_albums( 1067 1067 + &self, 1068 1068 + request: tonic::Request<super::GetLikedAlbumsRequest>, 1069 1069 + ) -> std::result::Result< 1070 1070 + tonic::Response<super::GetLikedAlbumsResponse>, 1071 1071 + tonic::Status, 1072 1072 + >; 1073 1073 + async fn scan_library( 1074 1074 + &self, 1075 1075 + request: tonic::Request<super::ScanLibraryRequest>, 1076 1076 + ) -> std::result::Result< 1077 1077 + tonic::Response<super::ScanLibraryResponse>, 1078 1078 + tonic::Status, 1079 1079 + >; 1080 1080 + async fn search( 1081 1081 + &self, 1082 1082 + request: tonic::Request<super::SearchRequest>, 1083 1083 + ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status>; 1084 1084 + } 1085 1085 + #[derive(Debug)] 1086 1086 + pub struct LibraryServiceServer<T> { 1087 1087 + inner: Arc<T>, 1088 1088 + accept_compression_encodings: EnabledCompressionEncodings, 1089 1089 + send_compression_encodings: EnabledCompressionEncodings, 1090 1090 + max_decoding_message_size: Option<usize>, 1091 1091 + max_encoding_message_size: Option<usize>, 1092 1092 + } 1093 1093 + impl<T> LibraryServiceServer<T> { 1094 1094 + pub fn new(inner: T) -> Self { 1095 1095 + Self::from_arc(Arc::new(inner)) 1096 1096 + } 1097 1097 + pub fn from_arc(inner: Arc<T>) -> Self { 1098 1098 + Self { 1099 1099 + inner, 1100 1100 + accept_compression_encodings: Default::default(), 1101 1101 + send_compression_encodings: Default::default(), 1102 1102 + max_decoding_message_size: None, 1103 1103 + max_encoding_message_size: None, 1104 1104 + } 1105 1105 + } 1106 1106 + pub fn with_interceptor<F>( 1107 1107 + inner: T, 1108 1108 + interceptor: F, 1109 1109 + ) -> InterceptedService<Self, F> 1110 1110 + where 1111 1111 + F: tonic::service::Interceptor, 1112 1112 + { 1113 1113 + InterceptedService::new(Self::new(inner), interceptor) 1114 1114 + } 1115 1115 + /// Enable decompressing requests with the given encoding. 1116 1116 + #[must_use] 1117 1117 + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { 1118 1118 + self.accept_compression_encodings.enable(encoding); 1119 1119 + self 1120 1120 + } 1121 1121 + /// Compress responses with the given encoding, if the client supports it. 1122 1122 + #[must_use] 1123 1123 + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { 1124 1124 + self.send_compression_encodings.enable(encoding); 1125 1125 + self 1126 1126 + } 1127 1127 + /// Limits the maximum size of a decoded message. 1128 1128 + /// 1129 1129 + /// Default: `4MB` 1130 1130 + #[must_use] 1131 1131 + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { 1132 1132 + self.max_decoding_message_size = Some(limit); 1133 1133 + self 1134 1134 + } 1135 1135 + /// Limits the maximum size of an encoded message. 1136 1136 + /// 1137 1137 + /// Default: `usize::MAX` 1138 1138 + #[must_use] 1139 1139 + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { 1140 1140 + self.max_encoding_message_size = Some(limit); 1141 1141 + self 1142 1142 + } 1143 1143 + } 1144 1144 + impl<T, B> tonic::codegen::Service<http::Request<B>> for LibraryServiceServer<T> 1145 1145 + where 1146 1146 + T: LibraryService, 1147 1147 + B: Body + std::marker::Send + 'static, 1148 1148 + B::Error: Into<StdError> + std::marker::Send + 'static, 1149 1149 + { 1150 1150 + type Response = http::Response<tonic::body::BoxBody>; 1151 1151 + type Error = std::convert::Infallible; 1152 1152 + type Future = BoxFuture<Self::Response, Self::Error>; 1153 1153 + fn poll_ready( 1154 1154 + &mut self, 1155 1155 + _cx: &mut Context<'_>, 1156 1156 + ) -> Poll<std::result::Result<(), Self::Error>> { 1157 1157 + Poll::Ready(Ok(())) 1158 1158 + } 1159 1159 + fn call(&mut self, req: http::Request<B>) -> Self::Future { 1160 1160 + match req.uri().path() { 1161 1161 + "/rockbox.v1alpha1.LibraryService/GetAlbums" => { 1162 1162 + #[allow(non_camel_case_types)] 1163 1163 + struct GetAlbumsSvc<T: LibraryService>(pub Arc<T>); 1164 1164 + impl< 1165 1165 + T: LibraryService, 1166 1166 + > tonic::server::UnaryService<super::GetAlbumsRequest> 1167 1167 + for GetAlbumsSvc<T> { 1168 1168 + type Response = super::GetAlbumsResponse; 1169 1169 + type Future = BoxFuture< 1170 1170 + tonic::Response<Self::Response>, 1171 1171 + tonic::Status, 1172 1172 + >; 1173 1173 + fn call( 1174 1174 + &mut self, 1175 1175 + request: tonic::Request<super::GetAlbumsRequest>, 1176 1176 + ) -> Self::Future { 1177 1177 + let inner = Arc::clone(&self.0); 1178 1178 + let fut = async move { 1179 1179 + <T as LibraryService>::get_albums(&inner, request).await 1180 1180 + }; 1181 1181 + Box::pin(fut) 1182 1182 + } 1183 1183 + } 1184 1184 + let accept_compression_encodings = self.accept_compression_encodings; 1185 1185 + let send_compression_encodings = self.send_compression_encodings; 1186 1186 + let max_decoding_message_size = self.max_decoding_message_size; 1187 1187 + let max_encoding_message_size = self.max_encoding_message_size; 1188 1188 + let inner = self.inner.clone(); 1189 1189 + let fut = async move { 1190 1190 + let method = GetAlbumsSvc(inner); 1191 1191 + let codec = tonic::codec::ProstCodec::default(); 1192 1192 + let mut grpc = tonic::server::Grpc::new(codec) 1193 1193 + .apply_compression_config( 1194 1194 + accept_compression_encodings, 1195 1195 + send_compression_encodings, 1196 1196 + ) 1197 1197 + .apply_max_message_size_config( 1198 1198 + max_decoding_message_size, 1199 1199 + max_encoding_message_size, 1200 1200 + ); 1201 1201 + let res = grpc.unary(method, req).await; 1202 1202 + Ok(res) 1203 1203 + }; 1204 1204 + Box::pin(fut) 1205 1205 + } 1206 1206 + "/rockbox.v1alpha1.LibraryService/GetArtists" => { 1207 1207 + #[allow(non_camel_case_types)] 1208 1208 + struct GetArtistsSvc<T: LibraryService>(pub Arc<T>); 1209 1209 + impl< 1210 1210 + T: LibraryService, 1211 1211 + > tonic::server::UnaryService<super::GetArtistsRequest> 1212 1212 + for GetArtistsSvc<T> { 1213 1213 + type Response = super::GetArtistsResponse; 1214 1214 + type Future = BoxFuture< 1215 1215 + tonic::Response<Self::Response>, 1216 1216 + tonic::Status, 1217 1217 + >; 1218 1218 + fn call( 1219 1219 + &mut self, 1220 1220 + request: tonic::Request<super::GetArtistsRequest>, 1221 1221 + ) -> Self::Future { 1222 1222 + let inner = Arc::clone(&self.0); 1223 1223 + let fut = async move { 1224 1224 + <T as LibraryService>::get_artists(&inner, request).await 1225 1225 + }; 1226 1226 + Box::pin(fut) 1227 1227 + } 1228 1228 + } 1229 1229 + let accept_compression_encodings = self.accept_compression_encodings; 1230 1230 + let send_compression_encodings = self.send_compression_encodings; 1231 1231 + let max_decoding_message_size = self.max_decoding_message_size; 1232 1232 + let max_encoding_message_size = self.max_encoding_message_size; 1233 1233 + let inner = self.inner.clone(); 1234 1234 + let fut = async move { 1235 1235 + let method = GetArtistsSvc(inner); 1236 1236 + let codec = tonic::codec::ProstCodec::default(); 1237 1237 + let mut grpc = tonic::server::Grpc::new(codec) 1238 1238 + .apply_compression_config( 1239 1239 + accept_compression_encodings, 1240 1240 + send_compression_encodings, 1241 1241 + ) 1242 1242 + .apply_max_message_size_config( 1243 1243 + max_decoding_message_size, 1244 1244 + max_encoding_message_size, 1245 1245 + ); 1246 1246 + let res = grpc.unary(method, req).await; 1247 1247 + Ok(res) 1248 1248 + }; 1249 1249 + Box::pin(fut) 1250 1250 + } 1251 1251 + "/rockbox.v1alpha1.LibraryService/GetTracks" => { 1252 1252 + #[allow(non_camel_case_types)] 1253 1253 + struct GetTracksSvc<T: LibraryService>(pub Arc<T>); 1254 1254 + impl< 1255 1255 + T: LibraryService, 1256 1256 + > tonic::server::UnaryService<super::GetTracksRequest> 1257 1257 + for GetTracksSvc<T> { 1258 1258 + type Response = super::GetTracksResponse; 1259 1259 + type Future = BoxFuture< 1260 1260 + tonic::Response<Self::Response>, 1261 1261 + tonic::Status, 1262 1262 + >; 1263 1263 + fn call( 1264 1264 + &mut self, 1265 1265 + request: tonic::Request<super::GetTracksRequest>, 1266 1266 + ) -> Self::Future { 1267 1267 + let inner = Arc::clone(&self.0); 1268 1268 + let fut = async move { 1269 1269 + <T as LibraryService>::get_tracks(&inner, request).await 1270 1270 + }; 1271 1271 + Box::pin(fut) 1272 1272 + } 1273 1273 + } 1274 1274 + let accept_compression_encodings = self.accept_compression_encodings; 1275 1275 + let send_compression_encodings = self.send_compression_encodings; 1276 1276 + let max_decoding_message_size = self.max_decoding_message_size; 1277 1277 + let max_encoding_message_size = self.max_encoding_message_size; 1278 1278 + let inner = self.inner.clone(); 1279 1279 + let fut = async move { 1280 1280 + let method = GetTracksSvc(inner); 1281 1281 + let codec = tonic::codec::ProstCodec::default(); 1282 1282 + let mut grpc = tonic::server::Grpc::new(codec) 1283 1283 + .apply_compression_config( 1284 1284 + accept_compression_encodings, 1285 1285 + send_compression_encodings, 1286 1286 + ) 1287 1287 + .apply_max_message_size_config( 1288 1288 + max_decoding_message_size, 1289 1289 + max_encoding_message_size, 1290 1290 + ); 1291 1291 + let res = grpc.unary(method, req).await; 1292 1292 + Ok(res) 1293 1293 + }; 1294 1294 + Box::pin(fut) 1295 1295 + } 1296 1296 + "/rockbox.v1alpha1.LibraryService/GetAlbum" => { 1297 1297 + #[allow(non_camel_case_types)] 1298 1298 + struct GetAlbumSvc<T: LibraryService>(pub Arc<T>); 1299 1299 + impl< 1300 1300 + T: LibraryService, 1301 1301 + > tonic::server::UnaryService<super::GetAlbumRequest> 1302 1302 + for GetAlbumSvc<T> { 1303 1303 + type Response = super::GetAlbumResponse; 1304 1304 + type Future = BoxFuture< 1305 1305 + tonic::Response<Self::Response>, 1306 1306 + tonic::Status, 1307 1307 + >; 1308 1308 + fn call( 1309 1309 + &mut self, 1310 1310 + request: tonic::Request<super::GetAlbumRequest>, 1311 1311 + ) -> Self::Future { 1312 1312 + let inner = Arc::clone(&self.0); 1313 1313 + let fut = async move { 1314 1314 + <T as LibraryService>::get_album(&inner, request).await 1315 1315 + }; 1316 1316 + Box::pin(fut) 1317 1317 + } 1318 1318 + } 1319 1319 + let accept_compression_encodings = self.accept_compression_encodings; 1320 1320 + let send_compression_encodings = self.send_compression_encodings; 1321 1321 + let max_decoding_message_size = self.max_decoding_message_size; 1322 1322 + let max_encoding_message_size = self.max_encoding_message_size; 1323 1323 + let inner = self.inner.clone(); 1324 1324 + let fut = async move { 1325 1325 + let method = GetAlbumSvc(inner); 1326 1326 + let codec = tonic::codec::ProstCodec::default(); 1327 1327 + let mut grpc = tonic::server::Grpc::new(codec) 1328 1328 + .apply_compression_config( 1329 1329 + accept_compression_encodings, 1330 1330 + send_compression_encodings, 1331 1331 + ) 1332 1332 + .apply_max_message_size_config( 1333 1333 + max_decoding_message_size, 1334 1334 + max_encoding_message_size, 1335 1335 + ); 1336 1336 + let res = grpc.unary(method, req).await; 1337 1337 + Ok(res) 1338 1338 + }; 1339 1339 + Box::pin(fut) 1340 1340 + } 1341 1341 + "/rockbox.v1alpha1.LibraryService/GetArtist" => { 1342 1342 + #[allow(non_camel_case_types)] 1343 1343 + struct GetArtistSvc<T: LibraryService>(pub Arc<T>); 1344 1344 + impl< 1345 1345 + T: LibraryService, 1346 1346 + > tonic::server::UnaryService<super::GetArtistRequest> 1347 1347 + for GetArtistSvc<T> { 1348 1348 + type Response = super::GetArtistResponse; 1349 1349 + type Future = BoxFuture< 1350 1350 + tonic::Response<Self::Response>, 1351 1351 + tonic::Status, 1352 1352 + >; 1353 1353 + fn call( 1354 1354 + &mut self, 1355 1355 + request: tonic::Request<super::GetArtistRequest>, 1356 1356 + ) -> Self::Future { 1357 1357 + let inner = Arc::clone(&self.0); 1358 1358 + let fut = async move { 1359 1359 + <T as LibraryService>::get_artist(&inner, request).await 1360 1360 + }; 1361 1361 + Box::pin(fut) 1362 1362 + } 1363 1363 + } 1364 1364 + let accept_compression_encodings = self.accept_compression_encodings; 1365 1365 + let send_compression_encodings = self.send_compression_encodings; 1366 1366 + let max_decoding_message_size = self.max_decoding_message_size; 1367 1367 + let max_encoding_message_size = self.max_encoding_message_size; 1368 1368 + let inner = self.inner.clone(); 1369 1369 + let fut = async move { 1370 1370 + let method = GetArtistSvc(inner); 1371 1371 + let codec = tonic::codec::ProstCodec::default(); 1372 1372 + let mut grpc = tonic::server::Grpc::new(codec) 1373 1373 + .apply_compression_config( 1374 1374 + accept_compression_encodings, 1375 1375 + send_compression_encodings, 1376 1376 + ) 1377 1377 + .apply_max_message_size_config( 1378 1378 + max_decoding_message_size, 1379 1379 + max_encoding_message_size, 1380 1380 + ); 1381 1381 + let res = grpc.unary(method, req).await; 1382 1382 + Ok(res) 1383 1383 + }; 1384 1384 + Box::pin(fut) 1385 1385 + } 1386 1386 + "/rockbox.v1alpha1.LibraryService/GetTrack" => { 1387 1387 + #[allow(non_camel_case_types)] 1388 1388 + struct GetTrackSvc<T: LibraryService>(pub Arc<T>); 1389 1389 + impl< 1390 1390 + T: LibraryService, 1391 1391 + > tonic::server::UnaryService<super::GetTrackRequest> 1392 1392 + for GetTrackSvc<T> { 1393 1393 + type Response = super::GetTrackResponse; 1394 1394 + type Future = BoxFuture< 1395 1395 + tonic::Response<Self::Response>, 1396 1396 + tonic::Status, 1397 1397 + >; 1398 1398 + fn call( 1399 1399 + &mut self, 1400 1400 + request: tonic::Request<super::GetTrackRequest>, 1401 1401 + ) -> Self::Future { 1402 1402 + let inner = Arc::clone(&self.0); 1403 1403 + let fut = async move { 1404 1404 + <T as LibraryService>::get_track(&inner, request).await 1405 1405 + }; 1406 1406 + Box::pin(fut) 1407 1407 + } 1408 1408 + } 1409 1409 + let accept_compression_encodings = self.accept_compression_encodings; 1410 1410 + let send_compression_encodings = self.send_compression_encodings; 1411 1411 + let max_decoding_message_size = self.max_decoding_message_size; 1412 1412 + let max_encoding_message_size = self.max_encoding_message_size; 1413 1413 + let inner = self.inner.clone(); 1414 1414 + let fut = async move { 1415 1415 + let method = GetTrackSvc(inner); 1416 1416 + let codec = tonic::codec::ProstCodec::default(); 1417 1417 + let mut grpc = tonic::server::Grpc::new(codec) 1418 1418 + .apply_compression_config( 1419 1419 + accept_compression_encodings, 1420 1420 + send_compression_encodings, 1421 1421 + ) 1422 1422 + .apply_max_message_size_config( 1423 1423 + max_decoding_message_size, 1424 1424 + max_encoding_message_size, 1425 1425 + ); 1426 1426 + let res = grpc.unary(method, req).await; 1427 1427 + Ok(res) 1428 1428 + }; 1429 1429 + Box::pin(fut) 1430 1430 + } 1431 1431 + "/rockbox.v1alpha1.LibraryService/LikeTrack" => { 1432 1432 + #[allow(non_camel_case_types)] 1433 1433 + struct LikeTrackSvc<T: LibraryService>(pub Arc<T>); 1434 1434 + impl< 1435 1435 + T: LibraryService, 1436 1436 + > tonic::server::UnaryService<super::LikeTrackRequest> 1437 1437 + for LikeTrackSvc<T> { 1438 1438 + type Response = super::LikeTrackResponse; 1439 1439 + type Future = BoxFuture< 1440 1440 + tonic::Response<Self::Response>, 1441 1441 + tonic::Status, 1442 1442 + >; 1443 1443 + fn call( 1444 1444 + &mut self, 1445 1445 + request: tonic::Request<super::LikeTrackRequest>, 1446 1446 + ) -> Self::Future { 1447 1447 + let inner = Arc::clone(&self.0); 1448 1448 + let fut = async move { 1449 1449 + <T as LibraryService>::like_track(&inner, request).await 1450 1450 + }; 1451 1451 + Box::pin(fut) 1452 1452 + } 1453 1453 + } 1454 1454 + let accept_compression_encodings = self.accept_compression_encodings; 1455 1455 + let send_compression_encodings = self.send_compression_encodings; 1456 1456 + let max_decoding_message_size = self.max_decoding_message_size; 1457 1457 + let max_encoding_message_size = self.max_encoding_message_size; 1458 1458 + let inner = self.inner.clone(); 1459 1459 + let fut = async move { 1460 1460 + let method = LikeTrackSvc(inner); 1461 1461 + let codec = tonic::codec::ProstCodec::default(); 1462 1462 + let mut grpc = tonic::server::Grpc::new(codec) 1463 1463 + .apply_compression_config( 1464 1464 + accept_compression_encodings, 1465 1465 + send_compression_encodings, 1466 1466 + ) 1467 1467 + .apply_max_message_size_config( 1468 1468 + max_decoding_message_size, 1469 1469 + max_encoding_message_size, 1470 1470 + ); 1471 1471 + let res = grpc.unary(method, req).await; 1472 1472 + Ok(res) 1473 1473 + }; 1474 1474 + Box::pin(fut) 1475 1475 + } 1476 1476 + "/rockbox.v1alpha1.LibraryService/UnlikeTrack" => { 1477 1477 + #[allow(non_camel_case_types)] 1478 1478 + struct UnlikeTrackSvc<T: LibraryService>(pub Arc<T>); 1479 1479 + impl< 1480 1480 + T: LibraryService, 1481 1481 + > tonic::server::UnaryService<super::UnlikeTrackRequest> 1482 1482 + for UnlikeTrackSvc<T> { 1483 1483 + type Response = super::UnlikeTrackResponse; 1484 1484 + type Future = BoxFuture< 1485 1485 + tonic::Response<Self::Response>, 1486 1486 + tonic::Status, 1487 1487 + >; 1488 1488 + fn call( 1489 1489 + &mut self, 1490 1490 + request: tonic::Request<super::UnlikeTrackRequest>, 1491 1491 + ) -> Self::Future { 1492 1492 + let inner = Arc::clone(&self.0); 1493 1493 + let fut = async move { 1494 1494 + <T as LibraryService>::unlike_track(&inner, request).await 1495 1495 + }; 1496 1496 + Box::pin(fut) 1497 1497 + } 1498 1498 + } 1499 1499 + let accept_compression_encodings = self.accept_compression_encodings; 1500 1500 + let send_compression_encodings = self.send_compression_encodings; 1501 1501 + let max_decoding_message_size = self.max_decoding_message_size; 1502 1502 + let max_encoding_message_size = self.max_encoding_message_size; 1503 1503 + let inner = self.inner.clone(); 1504 1504 + let fut = async move { 1505 1505 + let method = UnlikeTrackSvc(inner); 1506 1506 + let codec = tonic::codec::ProstCodec::default(); 1507 1507 + let mut grpc = tonic::server::Grpc::new(codec) 1508 1508 + .apply_compression_config( 1509 1509 + accept_compression_encodings, 1510 1510 + send_compression_encodings, 1511 1511 + ) 1512 1512 + .apply_max_message_size_config( 1513 1513 + max_decoding_message_size, 1514 1514 + max_encoding_message_size, 1515 1515 + ); 1516 1516 + let res = grpc.unary(method, req).await; 1517 1517 + Ok(res) 1518 1518 + }; 1519 1519 + Box::pin(fut) 1520 1520 + } 1521 1521 + "/rockbox.v1alpha1.LibraryService/LikeAlbum" => { 1522 1522 + #[allow(non_camel_case_types)] 1523 1523 + struct LikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1524 1524 + impl< 1525 1525 + T: LibraryService, 1526 1526 + > tonic::server::UnaryService<super::LikeAlbumRequest> 1527 1527 + for LikeAlbumSvc<T> { 1528 1528 + type Response = super::LikeAlbumResponse; 1529 1529 + type Future = BoxFuture< 1530 1530 + tonic::Response<Self::Response>, 1531 1531 + tonic::Status, 1532 1532 + >; 1533 1533 + fn call( 1534 1534 + &mut self, 1535 1535 + request: tonic::Request<super::LikeAlbumRequest>, 1536 1536 + ) -> Self::Future { 1537 1537 + let inner = Arc::clone(&self.0); 1538 1538 + let fut = async move { 1539 1539 + <T as LibraryService>::like_album(&inner, request).await 1540 1540 + }; 1541 1541 + Box::pin(fut) 1542 1542 + } 1543 1543 + } 1544 1544 + let accept_compression_encodings = self.accept_compression_encodings; 1545 1545 + let send_compression_encodings = self.send_compression_encodings; 1546 1546 + let max_decoding_message_size = self.max_decoding_message_size; 1547 1547 + let max_encoding_message_size = self.max_encoding_message_size; 1548 1548 + let inner = self.inner.clone(); 1549 1549 + let fut = async move { 1550 1550 + let method = LikeAlbumSvc(inner); 1551 1551 + let codec = tonic::codec::ProstCodec::default(); 1552 1552 + let mut grpc = tonic::server::Grpc::new(codec) 1553 1553 + .apply_compression_config( 1554 1554 + accept_compression_encodings, 1555 1555 + send_compression_encodings, 1556 1556 + ) 1557 1557 + .apply_max_message_size_config( 1558 1558 + max_decoding_message_size, 1559 1559 + max_encoding_message_size, 1560 1560 + ); 1561 1561 + let res = grpc.unary(method, req).await; 1562 1562 + Ok(res) 1563 1563 + }; 1564 1564 + Box::pin(fut) 1565 1565 + } 1566 1566 + "/rockbox.v1alpha1.LibraryService/UnlikeAlbum" => { 1567 1567 + #[allow(non_camel_case_types)] 1568 1568 + struct UnlikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1569 1569 + impl< 1570 1570 + T: LibraryService, 1571 1571 + > tonic::server::UnaryService<super::UnlikeAlbumRequest> 1572 1572 + for UnlikeAlbumSvc<T> { 1573 1573 + type Response = super::UnlikeAlbumResponse; 1574 1574 + type Future = BoxFuture< 1575 1575 + tonic::Response<Self::Response>, 1576 1576 + tonic::Status, 1577 1577 + >; 1578 1578 + fn call( 1579 1579 + &mut self, 1580 1580 + request: tonic::Request<super::UnlikeAlbumRequest>, 1581 1581 + ) -> Self::Future { 1582 1582 + let inner = Arc::clone(&self.0); 1583 1583 + let fut = async move { 1584 1584 + <T as LibraryService>::unlike_album(&inner, request).await 1585 1585 + }; 1586 1586 + Box::pin(fut) 1587 1587 + } 1588 1588 + } 1589 1589 + let accept_compression_encodings = self.accept_compression_encodings; 1590 1590 + let send_compression_encodings = self.send_compression_encodings; 1591 1591 + let max_decoding_message_size = self.max_decoding_message_size; 1592 1592 + let max_encoding_message_size = self.max_encoding_message_size; 1593 1593 + let inner = self.inner.clone(); 1594 1594 + let fut = async move { 1595 1595 + let method = UnlikeAlbumSvc(inner); 1596 1596 + let codec = tonic::codec::ProstCodec::default(); 1597 1597 + let mut grpc = tonic::server::Grpc::new(codec) 1598 1598 + .apply_compression_config( 1599 1599 + accept_compression_encodings, 1600 1600 + send_compression_encodings, 1601 1601 + ) 1602 1602 + .apply_max_message_size_config( 1603 1603 + max_decoding_message_size, 1604 1604 + max_encoding_message_size, 1605 1605 + ); 1606 1606 + let res = grpc.unary(method, req).await; 1607 1607 + Ok(res) 1608 1608 + }; 1609 1609 + Box::pin(fut) 1610 1610 + } 1611 1611 + "/rockbox.v1alpha1.LibraryService/GetLikedTracks" => { 1612 1612 + #[allow(non_camel_case_types)] 1613 1613 + struct GetLikedTracksSvc<T: LibraryService>(pub Arc<T>); 1614 1614 + impl< 1615 1615 + T: LibraryService, 1616 1616 + > tonic::server::UnaryService<super::GetLikedTracksRequest> 1617 1617 + for GetLikedTracksSvc<T> { 1618 1618 + type Response = super::GetLikedTracksResponse; 1619 1619 + type Future = BoxFuture< 1620 1620 + tonic::Response<Self::Response>, 1621 1621 + tonic::Status, 1622 1622 + >; 1623 1623 + fn call( 1624 1624 + &mut self, 1625 1625 + request: tonic::Request<super::GetLikedTracksRequest>, 1626 1626 + ) -> Self::Future { 1627 1627 + let inner = Arc::clone(&self.0); 1628 1628 + let fut = async move { 1629 1629 + <T as LibraryService>::get_liked_tracks(&inner, request) 1630 1630 + .await 1631 1631 + }; 1632 1632 + Box::pin(fut) 1633 1633 + } 1634 1634 + } 1635 1635 + let accept_compression_encodings = self.accept_compression_encodings; 1636 1636 + let send_compression_encodings = self.send_compression_encodings; 1637 1637 + let max_decoding_message_size = self.max_decoding_message_size; 1638 1638 + let max_encoding_message_size = self.max_encoding_message_size; 1639 1639 + let inner = self.inner.clone(); 1640 1640 + let fut = async move { 1641 1641 + let method = GetLikedTracksSvc(inner); 1642 1642 + let codec = tonic::codec::ProstCodec::default(); 1643 1643 + let mut grpc = tonic::server::Grpc::new(codec) 1644 1644 + .apply_compression_config( 1645 1645 + accept_compression_encodings, 1646 1646 + send_compression_encodings, 1647 1647 + ) 1648 1648 + .apply_max_message_size_config( 1649 1649 + max_decoding_message_size, 1650 1650 + max_encoding_message_size, 1651 1651 + ); 1652 1652 + let res = grpc.unary(method, req).await; 1653 1653 + Ok(res) 1654 1654 + }; 1655 1655 + Box::pin(fut) 1656 1656 + } 1657 1657 + "/rockbox.v1alpha1.LibraryService/GetLikedAlbums" => { 1658 1658 + #[allow(non_camel_case_types)] 1659 1659 + struct GetLikedAlbumsSvc<T: LibraryService>(pub Arc<T>); 1660 1660 + impl< 1661 1661 + T: LibraryService, 1662 1662 + > tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1663 1663 + for GetLikedAlbumsSvc<T> { 1664 1664 + type Response = super::GetLikedAlbumsResponse; 1665 1665 + type Future = BoxFuture< 1666 1666 + tonic::Response<Self::Response>, 1667 1667 + tonic::Status, 1668 1668 + >; 1669 1669 + fn call( 1670 1670 + &mut self, 1671 1671 + request: tonic::Request<super::GetLikedAlbumsRequest>, 1672 1672 + ) -> Self::Future { 1673 1673 + let inner = Arc::clone(&self.0); 1674 1674 + let fut = async move { 1675 1675 + <T as LibraryService>::get_liked_albums(&inner, request) 1676 1676 + .await 1677 1677 + }; 1678 1678 + Box::pin(fut) 1679 1679 + } 1680 1680 + } 1681 1681 + let accept_compression_encodings = self.accept_compression_encodings; 1682 1682 + let send_compression_encodings = self.send_compression_encodings; 1683 1683 + let max_decoding_message_size = self.max_decoding_message_size; 1684 1684 + let max_encoding_message_size = self.max_encoding_message_size; 1685 1685 + let inner = self.inner.clone(); 1686 1686 + let fut = async move { 1687 1687 + let method = GetLikedAlbumsSvc(inner); 1688 1688 + let codec = tonic::codec::ProstCodec::default(); 1689 1689 + let mut grpc = tonic::server::Grpc::new(codec) 1690 1690 + .apply_compression_config( 1691 1691 + accept_compression_encodings, 1692 1692 + send_compression_encodings, 1693 1693 + ) 1694 1694 + .apply_max_message_size_config( 1695 1695 + max_decoding_message_size, 1696 1696 + max_encoding_message_size, 1697 1697 + ); 1698 1698 + let res = grpc.unary(method, req).await; 1699 1699 + Ok(res) 1700 1700 + }; 1701 1701 + Box::pin(fut) 1702 1702 + } 1703 1703 + "/rockbox.v1alpha1.LibraryService/ScanLibrary" => { 1704 1704 + #[allow(non_camel_case_types)] 1705 1705 + struct ScanLibrarySvc<T: LibraryService>(pub Arc<T>); 1706 1706 + impl< 1707 1707 + T: LibraryService, 1708 1708 + > tonic::server::UnaryService<super::ScanLibraryRequest> 1709 1709 + for ScanLibrarySvc<T> { 1710 1710 + type Response = super::ScanLibraryResponse; 1711 1711 + type Future = BoxFuture< 1712 1712 + tonic::Response<Self::Response>, 1713 1713 + tonic::Status, 1714 1714 + >; 1715 1715 + fn call( 1716 1716 + &mut self, 1717 1717 + request: tonic::Request<super::ScanLibraryRequest>, 1718 1718 + ) -> Self::Future { 1719 1719 + let inner = Arc::clone(&self.0); 1720 1720 + let fut = async move { 1721 1721 + <T as LibraryService>::scan_library(&inner, request).await 1722 1722 + }; 1723 1723 + Box::pin(fut) 1724 1724 + } 1725 1725 + } 1726 1726 + let accept_compression_encodings = self.accept_compression_encodings; 1727 1727 + let send_compression_encodings = self.send_compression_encodings; 1728 1728 + let max_decoding_message_size = self.max_decoding_message_size; 1729 1729 + let max_encoding_message_size = self.max_encoding_message_size; 1730 1730 + let inner = self.inner.clone(); 1731 1731 + let fut = async move { 1732 1732 + let method = ScanLibrarySvc(inner); 1733 1733 + let codec = tonic::codec::ProstCodec::default(); 1734 1734 + let mut grpc = tonic::server::Grpc::new(codec) 1735 1735 + .apply_compression_config( 1736 1736 + accept_compression_encodings, 1737 1737 + send_compression_encodings, 1738 1738 + ) 1739 1739 + .apply_max_message_size_config( 1740 1740 + max_decoding_message_size, 1741 1741 + max_encoding_message_size, 1742 1742 + ); 1743 1743 + let res = grpc.unary(method, req).await; 1744 1744 + Ok(res) 1745 1745 + }; 1746 1746 + Box::pin(fut) 1747 1747 + } 1748 1748 + "/rockbox.v1alpha1.LibraryService/Search" => { 1749 1749 + #[allow(non_camel_case_types)] 1750 1750 + struct SearchSvc<T: LibraryService>(pub Arc<T>); 1751 1751 + impl< 1752 1752 + T: LibraryService, 1753 1753 + > tonic::server::UnaryService<super::SearchRequest> 1754 1754 + for SearchSvc<T> { 1755 1755 + type Response = super::SearchResponse; 1756 1756 + type Future = BoxFuture< 1757 1757 + tonic::Response<Self::Response>, 1758 1758 + tonic::Status, 1759 1759 + >; 1760 1760 + fn call( 1761 1761 + &mut self, 1762 1762 + request: tonic::Request<super::SearchRequest>, 1763 1763 + ) -> Self::Future { 1764 1764 + let inner = Arc::clone(&self.0); 1765 1765 + let fut = async move { 1766 1766 + <T as LibraryService>::search(&inner, request).await 1767 1767 + }; 1768 1768 + Box::pin(fut) 1769 1769 + } 1770 1770 + } 1771 1771 + let accept_compression_encodings = self.accept_compression_encodings; 1772 1772 + let send_compression_encodings = self.send_compression_encodings; 1773 1773 + let max_decoding_message_size = self.max_decoding_message_size; 1774 1774 + let max_encoding_message_size = self.max_encoding_message_size; 1775 1775 + let inner = self.inner.clone(); 1776 1776 + let fut = async move { 1777 1777 + let method = SearchSvc(inner); 1778 1778 + let codec = tonic::codec::ProstCodec::default(); 1779 1779 + let mut grpc = tonic::server::Grpc::new(codec) 1780 1780 + .apply_compression_config( 1781 1781 + accept_compression_encodings, 1782 1782 + send_compression_encodings, 1783 1783 + ) 1784 1784 + .apply_max_message_size_config( 1785 1785 + max_decoding_message_size, 1786 1786 + max_encoding_message_size, 1787 1787 + ); 1788 1788 + let res = grpc.unary(method, req).await; 1789 1789 + Ok(res) 1790 1790 + }; 1791 1791 + Box::pin(fut) 1792 1792 + } 1793 1793 + _ => { 1794 1794 + Box::pin(async move { 1795 1795 + let mut response = http::Response::new(empty_body()); 1796 1796 + let headers = response.headers_mut(); 1797 1797 + headers 1798 1798 + .insert( 1799 1799 + tonic::Status::GRPC_STATUS, 1800 1800 + (tonic::Code::Unimplemented as i32).into(), 1801 1801 + ); 1802 1802 + headers 1803 1803 + .insert( 1804 1804 + http::header::CONTENT_TYPE, 1805 1805 + tonic::metadata::GRPC_CONTENT_TYPE, 1806 1806 + ); 1807 1807 + Ok(response) 1808 1808 + }) 1809 1809 + } 1810 1810 + } 1811 1811 + } 1812 1812 + } 1813 1813 + impl<T> Clone for LibraryServiceServer<T> { 1814 1814 + fn clone(&self) -> Self { 1815 1815 + let inner = self.inner.clone(); 1816 1816 + Self { 1817 1817 + inner, 1818 1818 + accept_compression_encodings: self.accept_compression_encodings, 1819 1819 + send_compression_encodings: self.send_compression_encodings, 1820 1820 + max_decoding_message_size: self.max_decoding_message_size, 1821 1821 + max_encoding_message_size: self.max_encoding_message_size, 1822 1822 + } 1823 1823 + } 1824 1824 + } 1825 1825 + /// Generated gRPC service name 1826 1826 + pub const SERVICE_NAME: &str = "rockbox.v1alpha1.LibraryService"; 1827 1827 + impl<T> tonic::server::NamedService for LibraryServiceServer<T> { 1828 1828 + const NAME: &'static str = SERVICE_NAME; 1829 1829 + } 1830 1830 + } 1831 1831 + /// Generated client implementations. 1832 1832 + pub mod metadata_service_client { 1833 1833 + #![allow( 1834 1834 + unused_variables, 1835 1835 + dead_code, 1836 1836 + missing_docs, 1837 1837 + clippy::wildcard_imports, 1838 1838 + clippy::let_unit_value, 1839 1839 + )] 1840 1840 + use tonic::codegen::*; 1841 1841 + use tonic::codegen::http::Uri; 1842 1842 + #[derive(Debug, Clone)] 1843 1843 + pub struct MetadataServiceClient<T> { 1844 1844 + inner: tonic::client::Grpc<T>, 1845 1845 + } 1846 1846 + impl MetadataServiceClient<tonic::transport::Channel> { 1847 1847 + /// Attempt to create a new client by connecting to a given endpoint. 1848 1848 + pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error> 1849 1849 + where 1850 1850 + D: TryInto<tonic::transport::Endpoint>, 1851 1851 + D::Error: Into<StdError>, 1852 1852 + { 1853 1853 + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; 1854 1854 + Ok(Self::new(conn)) 1855 1855 + } 1856 1856 + } 1857 1857 + impl<T> MetadataServiceClient<T> 1858 1858 + where 1859 1859 + T: tonic::client::GrpcService<tonic::body::BoxBody>, 1860 1860 + T::Error: Into<StdError>, 1861 1861 + T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static, 1862 1862 + <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send, 1863 1863 + { 1864 1864 + pub fn new(inner: T) -> Self { 1865 1865 + let inner = tonic::client::Grpc::new(inner); 1866 1866 + Self { inner } 1867 1867 + } 1868 1868 + pub fn with_origin(inner: T, origin: Uri) -> Self { 1869 1869 + let inner = tonic::client::Grpc::with_origin(inner, origin); 1870 1870 + Self { inner } 1871 1871 + } 1872 1872 + pub fn with_interceptor<F>( 1873 1873 + inner: T, 1874 1874 + interceptor: F, 1875 1875 + ) -> MetadataServiceClient<InterceptedService<T, F>> 1876 1876 + where 1877 1877 + F: tonic::service::Interceptor, 1878 1878 + T::ResponseBody: Default, 1879 1879 + T: tonic::codegen::Service< 1880 1880 + http::Request<tonic::body::BoxBody>, 1881 1881 + Response = http::Response< 1882 1882 + <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 1883 1883 + >, 1884 1884 + >, 1885 1885 + <T as tonic::codegen::Service< 1886 1886 + http::Request<tonic::body::BoxBody>, 1887 1887 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 1888 1888 + { 1889 1889 + MetadataServiceClient::new(InterceptedService::new(inner, interceptor)) 1890 1890 + } 1891 1891 + /// Compress requests with the given encoding. 1892 1892 + /// 1893 1893 + /// This requires the server to support it otherwise it might respond with an 1894 1894 + /// error. 1895 1895 + #[must_use] 1896 1896 + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { 1897 1897 + self.inner = self.inner.send_compressed(encoding); 1898 1898 + self 1899 1899 + } 1900 1900 + /// Enable decompressing responses. 1901 1901 + #[must_use] 1902 1902 + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { 1903 1903 + self.inner = self.inner.accept_compressed(encoding); 1904 1904 + self 1905 1905 + } 1906 1906 + /// Limits the maximum size of a decoded message. 1907 1907 + /// 1908 1908 + /// Default: `4MB` 1909 1909 + #[must_use] 1910 1910 + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { 1911 1911 + self.inner = self.inner.max_decoding_message_size(limit); 1912 1912 + self 1913 1913 + } 1914 1914 + /// Limits the maximum size of an encoded message. 1915 1915 + /// 1916 1916 + /// Default: `usize::MAX` 1917 1917 + #[must_use] 1918 1918 + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { 1919 1919 + self.inner = self.inner.max_encoding_message_size(limit); 1920 1920 + self 1921 1921 + } 1922 1922 + } 1923 1923 + } 1924 1924 + /// Generated server implementations. 1925 1925 + pub mod metadata_service_server { 1926 1926 + #![allow( 1927 1927 + unused_variables, 1928 1928 + dead_code, 1929 1929 + missing_docs, 1930 1930 + clippy::wildcard_imports, 1931 1931 + clippy::let_unit_value, 1932 1932 + )] 1933 1933 + use tonic::codegen::*; 1934 1934 + /// Generated trait containing gRPC methods that should be implemented for use with MetadataServiceServer. 1935 1935 + #[async_trait] 1936 1936 + pub trait MetadataService: std::marker::Send + std::marker::Sync + 'static {} 1937 1937 + #[derive(Debug)] 1938 1938 + pub struct MetadataServiceServer<T> { 1939 1939 + inner: Arc<T>, 1940 1940 + accept_compression_encodings: EnabledCompressionEncodings, 1941 1941 + send_compression_encodings: EnabledCompressionEncodings, 1942 1942 + max_decoding_message_size: Option<usize>, 1943 1943 + max_encoding_message_size: Option<usize>, 1944 1944 + } 1945 1945 + impl<T> MetadataServiceServer<T> { 1946 1946 + pub fn new(inner: T) -> Self { 1947 1947 + Self::from_arc(Arc::new(inner)) 1948 1948 + } 1949 1949 + pub fn from_arc(inner: Arc<T>) -> Self { 1950 1950 + Self { 1951 1951 + inner, 1952 1952 + accept_compression_encodings: Default::default(), 1953 1953 + send_compression_encodings: Default::default(), 1954 1954 + max_decoding_message_size: None, 1955 1955 + max_encoding_message_size: None, 1956 1956 + } 1957 1957 + } 1958 1958 + pub fn with_interceptor<F>( 1959 1959 + inner: T, 1960 1960 + interceptor: F, 1961 1961 + ) -> InterceptedService<Self, F> 1962 1962 + where 1963 1963 + F: tonic::service::Interceptor, 1964 1964 + { 1965 1965 + InterceptedService::new(Self::new(inner), interceptor) 1966 1966 + } 1967 1967 + /// Enable decompressing requests with the given encoding. 1968 1968 + #[must_use] 1969 1969 + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { 1970 1970 + self.accept_compression_encodings.enable(encoding); 1971 1971 + self 1972 1972 + } 1973 1973 + /// Compress responses with the given encoding, if the client supports it. 1974 1974 + #[must_use] 1975 1975 + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { 1976 1976 + self.send_compression_encodings.enable(encoding); 1977 1977 + self 1978 1978 + } 1979 1979 + /// Limits the maximum size of a decoded message. 1980 1980 + /// 1981 1981 + /// Default: `4MB` 1982 1982 + #[must_use] 1983 1983 + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { 1984 1984 + self.max_decoding_message_size = Some(limit); 1985 1985 + self 1986 1986 + } 1987 1987 + /// Limits the maximum size of an encoded message. 1988 1988 + /// 1989 1989 + /// Default: `usize::MAX` 1990 1990 + #[must_use] 1991 1991 + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { 1992 1992 + self.max_encoding_message_size = Some(limit); 1993 1993 + self 1994 1994 + } 1995 1995 + } 1996 1996 + impl<T, B> tonic::codegen::Service<http::Request<B>> for MetadataServiceServer<T> 1997 1997 + where 1998 1998 + T: MetadataService, 1999 1999 + B: Body + std::marker::Send + 'static, 2000 2000 + B::Error: Into<StdError> + std::marker::Send + 'static, 2001 2001 + { 2002 2002 + type Response = http::Response<tonic::body::BoxBody>; 2003 2003 + type Error = std::convert::Infallible; 2004 2004 + type Future = BoxFuture<Self::Response, Self::Error>; 2005 2005 + fn poll_ready( 2006 2006 + &mut self, 2007 2007 + _cx: &mut Context<'_>, 2008 2008 + ) -> Poll<std::result::Result<(), Self::Error>> { 2009 2009 + Poll::Ready(Ok(())) 2010 2010 + } 2011 2011 + fn call(&mut self, req: http::Request<B>) -> Self::Future { 2012 2012 + match req.uri().path() { 2013 2013 + _ => { 2014 2014 + Box::pin(async move { 2015 2015 + let mut response = http::Response::new(empty_body()); 2016 2016 + let headers = response.headers_mut(); 2017 2017 + headers 2018 2018 + .insert( 2019 2019 + tonic::Status::GRPC_STATUS, 2020 2020 + (tonic::Code::Unimplemented as i32).into(), 2021 2021 + ); 2022 2022 + headers 2023 2023 + .insert( 2024 2024 + http::header::CONTENT_TYPE, 2025 2025 + tonic::metadata::GRPC_CONTENT_TYPE, 2026 2026 + ); 2027 2027 + Ok(response) 2028 2028 + }) 2029 2029 + } 2030 2030 + } 2031 2031 + } 2032 2032 + } 2033 2033 + impl<T> Clone for MetadataServiceServer<T> { 2034 2034 + fn clone(&self) -> Self { 2035 2035 + let inner = self.inner.clone(); 2036 2036 + Self { 2037 2037 + inner, 2038 2038 + accept_compression_encodings: self.accept_compression_encodings, 2039 2039 + send_compression_encodings: self.send_compression_encodings, 2040 2040 + max_decoding_message_size: self.max_decoding_message_size, 2041 2041 + max_encoding_message_size: self.max_encoding_message_size, 2042 2042 + } 2043 2043 + } 2044 2044 + } 2045 2045 + /// Generated gRPC service name 2046 2046 + pub const SERVICE_NAME: &str = "rockbox.v1alpha1.MetadataService"; 2047 2047 + impl<T> tonic::server::NamedService for MetadataServiceServer<T> { 2048 2048 + const NAME: &'static str = SERVICE_NAME; 2049 2049 + } 2050 2050 + } 2051 2051 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2052 2052 + pub struct PlayRequest { 2053 2053 + #[prost(int64, tag = "1")] 2054 2054 + pub elapsed: i64, 2055 2055 + #[prost(int64, tag = "2")] 2056 2056 + pub offset: i64, 2057 2057 + } 2058 2058 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2059 2059 + pub struct PlayResponse {} 2060 2060 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2061 2061 + pub struct PauseRequest {} 2062 2062 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2063 2063 + pub struct PlayOrPauseRequest {} 2064 2064 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2065 2065 + pub struct PlayOrPauseResponse {} 2066 2066 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2067 2067 + pub struct PauseResponse {} 2068 2068 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2069 2069 + pub struct ResumeRequest {} 2070 2070 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2071 2071 + pub struct ResumeResponse {} 2072 2072 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2073 2073 + pub struct NextRequest {} 2074 2074 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2075 2075 + pub struct NextResponse {} 2076 2076 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2077 2077 + pub struct PreviousRequest {} 2078 2078 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2079 2079 + pub struct PreviousResponse {} 2080 2080 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2081 2081 + pub struct FastForwardRewindRequest { 2082 2082 + #[prost(int32, tag = "1")] 2083 2083 + pub new_time: i32, 2084 2084 + } 2085 2085 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2086 2086 + pub struct FastForwardRewindResponse {} 2087 2087 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2088 2088 + pub struct StatusRequest {} 2089 2089 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2090 2090 + pub struct StreamStatusRequest {} 2091 2091 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2092 2092 + pub struct StatusResponse { 2093 2093 + #[prost(int32, tag = "1")] 2094 2094 + pub status: i32, 2095 2095 + } 2096 2096 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2097 2097 + pub struct CurrentTrackRequest {} 2098 2098 + #[derive(Clone, PartialEq, ::prost::Message)] 2099 2099 + pub struct CurrentTrackResponse { 2100 2100 + #[prost(string, tag = "1")] 2101 2101 + pub title: ::prost::alloc::string::String, 2102 2102 + #[prost(string, tag = "2")] 2103 2103 + pub artist: ::prost::alloc::string::String, 2104 2104 + #[prost(string, tag = "3")] 2105 2105 + pub album: ::prost::alloc::string::String, 2106 2106 + #[prost(string, tag = "4")] 2107 2107 + pub genre: ::prost::alloc::string::String, 2108 2108 + #[prost(string, tag = "5")] 2109 2109 + pub disc: ::prost::alloc::string::String, 2110 2110 + #[prost(string, tag = "6")] 2111 2111 + pub track_string: ::prost::alloc::string::String, 2112 2112 + #[prost(string, tag = "7")] 2113 2113 + pub year_string: ::prost::alloc::string::String, 2114 2114 + #[prost(string, tag = "8")] 2115 2115 + pub composer: ::prost::alloc::string::String, 2116 2116 + #[prost(string, tag = "9")] 2117 2117 + pub comment: ::prost::alloc::string::String, 2118 2118 + #[prost(string, tag = "10")] 2119 2119 + pub album_artist: ::prost::alloc::string::String, 2120 2120 + #[prost(string, tag = "11")] 2121 2121 + pub grouping: ::prost::alloc::string::String, 2122 2122 + #[prost(int32, tag = "12")] 2123 2123 + pub discnum: i32, 2124 2124 + #[prost(int32, tag = "13")] 2125 2125 + pub tracknum: i32, 2126 2126 + #[prost(int32, tag = "14")] 2127 2127 + pub layer: i32, 2128 2128 + #[prost(int32, tag = "15")] 2129 2129 + pub year: i32, 2130 2130 + #[prost(uint32, tag = "16")] 2131 2131 + pub bitrate: u32, 2132 2132 + #[prost(uint64, tag = "17")] 2133 2133 + pub frequency: u64, 2134 2134 + #[prost(uint64, tag = "18")] 2135 2135 + pub filesize: u64, 2136 2136 + #[prost(uint64, tag = "19")] 2137 2137 + pub length: u64, 2138 2138 + #[prost(uint64, tag = "20")] 2139 2139 + pub elapsed: u64, 2140 2140 + #[prost(string, tag = "21")] 2141 2141 + pub path: ::prost::alloc::string::String, 2142 2142 + #[prost(string, optional, tag = "22")] 2143 2143 + pub album_art: ::core::option::Option<::prost::alloc::string::String>, 2144 2144 + #[prost(string, tag = "23")] 2145 2145 + pub album_id: ::prost::alloc::string::String, 2146 2146 + #[prost(string, tag = "24")] 2147 2147 + pub artist_id: ::prost::alloc::string::String, 2148 2148 + #[prost(string, tag = "25")] 2149 2149 + pub id: ::prost::alloc::string::String, 2150 2150 + } 2151 2151 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2152 2152 + pub struct StreamCurrentTrackRequest {} 2153 2153 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2154 2154 + pub struct NextTrackRequest {} 2155 2155 + #[derive(Clone, PartialEq, ::prost::Message)] 2156 2156 + pub struct NextTrackResponse { 2157 2157 + #[prost(string, tag = "1")] 2158 2158 + pub title: ::prost::alloc::string::String, 2159 2159 + #[prost(string, tag = "2")] 2160 2160 + pub artist: ::prost::alloc::string::String, 2161 2161 + #[prost(string, tag = "3")] 2162 2162 + pub album: ::prost::alloc::string::String, 2163 2163 + #[prost(string, tag = "4")] 2164 2164 + pub genre: ::prost::alloc::string::String, 2165 2165 + #[prost(string, tag = "5")] 2166 2166 + pub disc: ::prost::alloc::string::String, 2167 2167 + #[prost(string, tag = "6")] 2168 2168 + pub track_string: ::prost::alloc::string::String, 2169 2169 + #[prost(string, tag = "7")] 2170 2170 + pub year_string: ::prost::alloc::string::String, 2171 2171 + #[prost(string, tag = "8")] 2172 2172 + pub composer: ::prost::alloc::string::String, 2173 2173 + #[prost(string, tag = "9")] 2174 2174 + pub comment: ::prost::alloc::string::String, 2175 2175 + #[prost(string, tag = "10")] 2176 2176 + pub album_artist: ::prost::alloc::string::String, 2177 2177 + #[prost(string, tag = "11")] 2178 2178 + pub grouping: ::prost::alloc::string::String, 2179 2179 + #[prost(int32, tag = "12")] 2180 2180 + pub discnum: i32, 2181 2181 + #[prost(int32, tag = "13")] 2182 2182 + pub tracknum: i32, 2183 2183 + #[prost(int32, tag = "14")] 2184 2184 + pub layer: i32, 2185 2185 + #[prost(int32, tag = "15")] 2186 2186 + pub year: i32, 2187 2187 + #[prost(uint32, tag = "16")] 2188 2188 + pub bitrate: u32, 2189 2189 + #[prost(uint64, tag = "17")] 2190 2190 + pub frequency: u64, 2191 2191 + #[prost(uint64, tag = "18")] 2192 2192 + pub filesize: u64, 2193 2193 + #[prost(uint64, tag = "19")] 2194 2194 + pub length: u64, 2195 2195 + #[prost(uint64, tag = "20")] 2196 2196 + pub elapsed: u64, 2197 2197 + #[prost(string, tag = "21")] 2198 2198 + pub path: ::prost::alloc::string::String, 2199 2199 + } 2200 2200 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2201 2201 + pub struct FlushAndReloadTracksRequest {} 2202 2202 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2203 2203 + pub struct FlushAndReloadTracksResponse {} 2204 2204 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2205 2205 + pub struct GetFilePositionRequest {} 2206 2206 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2207 2207 + pub struct GetFilePositionResponse { 2208 2208 + #[prost(int32, tag = "1")] 2209 2209 + pub position: i32, 2210 2210 + } 2211 2211 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2212 2212 + pub struct HardStopRequest {} 2213 2213 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2214 2214 + pub struct HardStopResponse {} 2215 2215 + #[derive(Clone, PartialEq, ::prost::Message)] 2216 2216 + pub struct PlayAlbumRequest { 2217 2217 + #[prost(string, tag = "1")] 2218 2218 + pub album_id: ::prost::alloc::string::String, 2219 2219 + #[prost(bool, optional, tag = "2")] 2220 2220 + pub shuffle: ::core::option::Option<bool>, 2221 2221 + #[prost(int32, optional, tag = "3")] 2222 2222 + pub position: ::core::option::Option<i32>, 2223 2223 + } 2224 2224 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2225 2225 + pub struct PlayAlbumResponse {} 2226 2226 + #[derive(Clone, PartialEq, ::prost::Message)] 2227 2227 + pub struct PlayArtistTracksRequest { 2228 2228 + #[prost(string, tag = "1")] 2229 2229 + pub artist_id: ::prost::alloc::string::String, 2230 2230 + #[prost(bool, optional, tag = "2")] 2231 2231 + pub shuffle: ::core::option::Option<bool>, 2232 2232 + #[prost(int32, optional, tag = "3")] 2233 2233 + pub position: ::core::option::Option<i32>, 2234 2234 + } 2235 2235 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2236 2236 + pub struct PlayArtistTracksResponse {} 2237 2237 + #[derive(Clone, PartialEq, ::prost::Message)] 2238 2238 + pub struct PlayPlaylistRequest { 2239 2239 + #[prost(string, tag = "1")] 2240 2240 + pub playlist_id: ::prost::alloc::string::String, 2241 2241 + #[prost(bool, optional, tag = "2")] 2242 2242 + pub shuffle: ::core::option::Option<bool>, 2243 2243 + } 2244 2244 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2245 2245 + pub struct PlayPlaylistResponse {} 2246 2246 + #[derive(Clone, PartialEq, ::prost::Message)] 2247 2247 + pub struct PlayDirectoryRequest { 2248 2248 + #[prost(string, tag = "1")] 2249 2249 + pub path: ::prost::alloc::string::String, 2250 2250 + #[prost(bool, optional, tag = "2")] 2251 2251 + pub shuffle: ::core::option::Option<bool>, 2252 2252 + #[prost(bool, optional, tag = "3")] 2253 2253 + pub recurse: ::core::option::Option<bool>, 2254 2254 + #[prost(int32, optional, tag = "4")] 2255 2255 + pub position: ::core::option::Option<i32>, 2256 2256 + } 2257 2257 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2258 2258 + pub struct PlayDirectoryResponse {} 2259 2259 + #[derive(Clone, PartialEq, ::prost::Message)] 2260 2260 + pub struct PlayTrackRequest { 2261 2261 + #[prost(string, tag = "1")] 2262 2262 + pub path: ::prost::alloc::string::String, 2263 2263 + } 2264 2264 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2265 2265 + pub struct PlayTrackResponse {} 2266 2266 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2267 2267 + pub struct PlayLikedTracksRequest { 2268 2268 + #[prost(bool, optional, tag = "1")] 2269 2269 + pub shuffle: ::core::option::Option<bool>, 2270 2270 + #[prost(int32, optional, tag = "2")] 2271 2271 + pub position: ::core::option::Option<i32>, 2272 2272 + } 2273 2273 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2274 2274 + pub struct PlayLikedTracksResponse {} 2275 2275 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2276 2276 + pub struct PlayAllTracksRequest { 2277 2277 + #[prost(bool, optional, tag = "1")] 2278 2278 + pub shuffle: ::core::option::Option<bool>, 2279 2279 + #[prost(int32, optional, tag = "2")] 2280 2280 + pub position: ::core::option::Option<i32>, 2281 2281 + } 2282 2282 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2283 2283 + pub struct PlayAllTracksResponse {} 2284 2284 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 2285 2285 + pub struct StreamPlaylistRequest {} 2286 2286 + #[derive(Clone, PartialEq, ::prost::Message)] 2287 2287 + pub struct PlaylistResponse { 2288 2288 + #[prost(int32, tag = "1")] 2289 2289 + pub index: i32, 2290 2290 + #[prost(int32, tag = "2")] 2291 2291 + pub amount: i32, 2292 2292 + #[prost(message, repeated, tag = "3")] 2293 2293 + pub tracks: ::prost::alloc::vec::Vec<CurrentTrackResponse>, 2294 2294 + } 2295 2295 + /// Generated client implementations. 2296 2296 + pub mod playback_service_client { 2297 2297 + #![allow( 2298 2298 + unused_variables, 2299 2299 + dead_code, 2300 2300 + missing_docs, 2301 2301 + clippy::wildcard_imports, 2302 2302 + clippy::let_unit_value, 2303 2303 + )] 2304 2304 + use tonic::codegen::*; 2305 2305 + use tonic::codegen::http::Uri; 2306 2306 + #[derive(Debug, Clone)] 2307 2307 + pub struct PlaybackServiceClient<T> { 2308 2308 + inner: tonic::client::Grpc<T>, 2309 2309 + } 2310 2310 + impl PlaybackServiceClient<tonic::transport::Channel> { 2311 2311 + /// Attempt to create a new client by connecting to a given endpoint. 2312 2312 + pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error> 2313 2313 + where 2314 2314 + D: TryInto<tonic::transport::Endpoint>, 2315 2315 + D::Error: Into<StdError>, 2316 2316 + { 2317 2317 + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; 2318 2318 + Ok(Self::new(conn)) 2319 2319 + } 2320 2320 + } 2321 2321 + impl<T> PlaybackServiceClient<T> 2322 2322 + where 2323 2323 + T: tonic::client::GrpcService<tonic::body::BoxBody>, 2324 2324 + T::Error: Into<StdError>, 2325 2325 + T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static, 2326 2326 + <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send, 2327 2327 + { 2328 2328 + pub fn new(inner: T) -> Self { 2329 2329 + let inner = tonic::client::Grpc::new(inner); 2330 2330 + Self { inner } 2331 2331 + } 2332 2332 + pub fn with_origin(inner: T, origin: Uri) -> Self { 2333 2333 + let inner = tonic::client::Grpc::with_origin(inner, origin); 2334 2334 + Self { inner } 2335 2335 + } 2336 2336 + pub fn with_interceptor<F>( 2337 2337 + inner: T, 2338 2338 + interceptor: F, 2339 2339 + ) -> PlaybackServiceClient<InterceptedService<T, F>> 2340 2340 + where 2341 2341 + F: tonic::service::Interceptor, 2342 2342 + T::ResponseBody: Default, 2343 2343 + T: tonic::codegen::Service< 2344 2344 + http::Request<tonic::body::BoxBody>, 2345 2345 + Response = http::Response< 2346 2346 + <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 2347 2347 + >, 2348 2348 + >, 2349 2349 + <T as tonic::codegen::Service< 2350 2350 + http::Request<tonic::body::BoxBody>, 2351 2351 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 2352 2352 + { 2353 2353 + PlaybackServiceClient::new(InterceptedService::new(inner, interceptor)) 2354 2354 + } 2355 2355 + /// Compress requests with the given encoding. 2356 2356 + /// 2357 2357 + /// This requires the server to support it otherwise it might respond with an 2358 2358 + /// error. 2359 2359 + #[must_use] 2360 2360 + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { 2361 2361 + self.inner = self.inner.send_compressed(encoding); 2362 2362 + self 2363 2363 + } 2364 2364 + /// Enable decompressing responses. 2365 2365 + #[must_use] 2366 2366 + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { 2367 2367 + self.inner = self.inner.accept_compressed(encoding); 2368 2368 + self 2369 2369 + } 2370 2370 + /// Limits the maximum size of a decoded message. 2371 2371 + /// 2372 2372 + /// Default: `4MB` 2373 2373 + #[must_use] 2374 2374 + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { 2375 2375 + self.inner = self.inner.max_decoding_message_size(limit); 2376 2376 + self 2377 2377 + } 2378 2378 + /// Limits the maximum size of an encoded message. 2379 2379 + /// 2380 2380 + /// Default: `usize::MAX` 2381 2381 + #[must_use] 2382 2382 + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { 2383 2383 + self.inner = self.inner.max_encoding_message_size(limit); 2384 2384 + self 2385 2385 + } 2386 2386 + pub async fn play( 2387 2387 + &mut self, 2388 2388 + request: impl tonic::IntoRequest<super::PlayRequest>, 2389 2389 + ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> { 2390 2390 + self.inner 2391 2391 + .ready() 2392 2392 + .await 2393 2393 + .map_err(|e| { 2394 2394 + tonic::Status::unknown( 2395 2395 + format!("Service was not ready: {}", e.into()), 2396 2396 + ) 2397 2397 + })?; 2398 2398 + let codec = tonic::codec::ProstCodec::default(); 2399 2399 + let path = http::uri::PathAndQuery::from_static( 2400 2400 + "/rockbox.v1alpha1.PlaybackService/Play", 2401 2401 + ); 2402 2402 + let mut req = request.into_request(); 2403 2403 + req.extensions_mut() 2404 2404 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Play")); 2405 2405 + self.inner.unary(req, path, codec).await 2406 2406 + } 2407 2407 + pub async fn pause( 2408 2408 + &mut self, 2409 2409 + request: impl tonic::IntoRequest<super::PauseRequest>, 2410 2410 + ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> { 2411 2411 + self.inner 2412 2412 + .ready() 2413 2413 + .await 2414 2414 + .map_err(|e| { 2415 2415 + tonic::Status::unknown( 2416 2416 + format!("Service was not ready: {}", e.into()), 2417 2417 + ) 2418 2418 + })?; 2419 2419 + let codec = tonic::codec::ProstCodec::default(); 2420 2420 + let path = http::uri::PathAndQuery::from_static( 2421 2421 + "/rockbox.v1alpha1.PlaybackService/Pause", 2422 2422 + ); 2423 2423 + let mut req = request.into_request(); 2424 2424 + req.extensions_mut() 2425 2425 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Pause")); 2426 2426 + self.inner.unary(req, path, codec).await 2427 2427 + } 2428 2428 + pub async fn play_or_pause( 2429 2429 + &mut self, 2430 2430 + request: impl tonic::IntoRequest<super::PlayOrPauseRequest>, 2431 2431 + ) -> std::result::Result< 2432 2432 + tonic::Response<super::PlayOrPauseResponse>, 2433 2433 + tonic::Status, 2434 2434 + > { 2435 2435 + self.inner 2436 2436 + .ready() 2437 2437 + .await 2438 2438 + .map_err(|e| { 2439 2439 + tonic::Status::unknown( 2440 2440 + format!("Service was not ready: {}", e.into()), 2441 2441 + ) 2442 2442 + })?; 2443 2443 + let codec = tonic::codec::ProstCodec::default(); 2444 2444 + let path = http::uri::PathAndQuery::from_static( 2445 2445 + "/rockbox.v1alpha1.PlaybackService/PlayOrPause", 2446 2446 + ); 2447 2447 + let mut req = request.into_request(); 2448 2448 + req.extensions_mut() 2449 2449 + .insert( 2450 2450 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayOrPause"), 2451 2451 + ); 2452 2452 + self.inner.unary(req, path, codec).await 2453 2453 + } 2454 2454 + pub async fn resume( 2455 2455 + &mut self, 2456 2456 + request: impl tonic::IntoRequest<super::ResumeRequest>, 2457 2457 + ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> { 2458 2458 + self.inner 2459 2459 + .ready() 2460 2460 + .await 2461 2461 + .map_err(|e| { 2462 2462 + tonic::Status::unknown( 2463 2463 + format!("Service was not ready: {}", e.into()), 2464 2464 + ) 2465 2465 + })?; 2466 2466 + let codec = tonic::codec::ProstCodec::default(); 2467 2467 + let path = http::uri::PathAndQuery::from_static( 2468 2468 + "/rockbox.v1alpha1.PlaybackService/Resume", 2469 2469 + ); 2470 2470 + let mut req = request.into_request(); 2471 2471 + req.extensions_mut() 2472 2472 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Resume")); 2473 2473 + self.inner.unary(req, path, codec).await 2474 2474 + } 2475 2475 + pub async fn next( 2476 2476 + &mut self, 2477 2477 + request: impl tonic::IntoRequest<super::NextRequest>, 2478 2478 + ) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status> { 2479 2479 + self.inner 2480 2480 + .ready() 2481 2481 + .await 2482 2482 + .map_err(|e| { 2483 2483 + tonic::Status::unknown( 2484 2484 + format!("Service was not ready: {}", e.into()), 2485 2485 + ) 2486 2486 + })?; 2487 2487 + let codec = tonic::codec::ProstCodec::default(); 2488 2488 + let path = http::uri::PathAndQuery::from_static( 2489 2489 + "/rockbox.v1alpha1.PlaybackService/Next", 2490 2490 + ); 2491 2491 + let mut req = request.into_request(); 2492 2492 + req.extensions_mut() 2493 2493 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Next")); 2494 2494 + self.inner.unary(req, path, codec).await 2495 2495 + } 2496 2496 + pub async fn previous( 2497 2497 + &mut self, 2498 2498 + request: impl tonic::IntoRequest<super::PreviousRequest>, 2499 2499 + ) -> std::result::Result< 2500 2500 + tonic::Response<super::PreviousResponse>, 2501 2501 + tonic::Status, 2502 2502 + > { 2503 2503 + self.inner 2504 2504 + .ready() 2505 2505 + .await 2506 2506 + .map_err(|e| { 2507 2507 + tonic::Status::unknown( 2508 2508 + format!("Service was not ready: {}", e.into()), 2509 2509 + ) 2510 2510 + })?; 2511 2511 + let codec = tonic::codec::ProstCodec::default(); 2512 2512 + let path = http::uri::PathAndQuery::from_static( 2513 2513 + "/rockbox.v1alpha1.PlaybackService/Previous", 2514 2514 + ); 2515 2515 + let mut req = request.into_request(); 2516 2516 + req.extensions_mut() 2517 2517 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Previous")); 2518 2518 + self.inner.unary(req, path, codec).await 2519 2519 + } 2520 2520 + pub async fn fast_forward_rewind( 2521 2521 + &mut self, 2522 2522 + request: impl tonic::IntoRequest<super::FastForwardRewindRequest>, 2523 2523 + ) -> std::result::Result< 2524 2524 + tonic::Response<super::FastForwardRewindResponse>, 2525 2525 + tonic::Status, 2526 2526 + > { 2527 2527 + self.inner 2528 2528 + .ready() 2529 2529 + .await 2530 2530 + .map_err(|e| { 2531 2531 + tonic::Status::unknown( 2532 2532 + format!("Service was not ready: {}", e.into()), 2533 2533 + ) 2534 2534 + })?; 2535 2535 + let codec = tonic::codec::ProstCodec::default(); 2536 2536 + let path = http::uri::PathAndQuery::from_static( 2537 2537 + "/rockbox.v1alpha1.PlaybackService/FastForwardRewind", 2538 2538 + ); 2539 2539 + let mut req = request.into_request(); 2540 2540 + req.extensions_mut() 2541 2541 + .insert( 2542 2542 + GrpcMethod::new( 2543 2543 + "rockbox.v1alpha1.PlaybackService", 2544 2544 + "FastForwardRewind", 2545 2545 + ), 2546 2546 + ); 2547 2547 + self.inner.unary(req, path, codec).await 2548 2548 + } 2549 2549 + pub async fn status( 2550 2550 + &mut self, 2551 2551 + request: impl tonic::IntoRequest<super::StatusRequest>, 2552 2552 + ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> { 2553 2553 + self.inner 2554 2554 + .ready() 2555 2555 + .await 2556 2556 + .map_err(|e| { 2557 2557 + tonic::Status::unknown( 2558 2558 + format!("Service was not ready: {}", e.into()), 2559 2559 + ) 2560 2560 + })?; 2561 2561 + let codec = tonic::codec::ProstCodec::default(); 2562 2562 + let path = http::uri::PathAndQuery::from_static( 2563 2563 + "/rockbox.v1alpha1.PlaybackService/Status", 2564 2564 + ); 2565 2565 + let mut req = request.into_request(); 2566 2566 + req.extensions_mut() 2567 2567 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Status")); 2568 2568 + self.inner.unary(req, path, codec).await 2569 2569 + } 2570 2570 + pub async fn current_track( 2571 2571 + &mut self, 2572 2572 + request: impl tonic::IntoRequest<super::CurrentTrackRequest>, 2573 2573 + ) -> std::result::Result< 2574 2574 + tonic::Response<super::CurrentTrackResponse>, 2575 2575 + tonic::Status, 2576 2576 + > { 2577 2577 + self.inner 2578 2578 + .ready() 2579 2579 + .await 2580 2580 + .map_err(|e| { 2581 2581 + tonic::Status::unknown( 2582 2582 + format!("Service was not ready: {}", e.into()), 2583 2583 + ) 2584 2584 + })?; 2585 2585 + let codec = tonic::codec::ProstCodec::default(); 2586 2586 + let path = http::uri::PathAndQuery::from_static( 2587 2587 + "/rockbox.v1alpha1.PlaybackService/CurrentTrack", 2588 2588 + ); 2589 2589 + let mut req = request.into_request(); 2590 2590 + req.extensions_mut() 2591 2591 + .insert( 2592 2592 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "CurrentTrack"), 2593 2593 + ); 2594 2594 + self.inner.unary(req, path, codec).await 2595 2595 + } 2596 2596 + pub async fn next_track( 2597 2597 + &mut self, 2598 2598 + request: impl tonic::IntoRequest<super::NextTrackRequest>, 2599 2599 + ) -> std::result::Result< 2600 2600 + tonic::Response<super::NextTrackResponse>, 2601 2601 + tonic::Status, 2602 2602 + > { 2603 2603 + self.inner 2604 2604 + .ready() 2605 2605 + .await 2606 2606 + .map_err(|e| { 2607 2607 + tonic::Status::unknown( 2608 2608 + format!("Service was not ready: {}", e.into()), 2609 2609 + ) 2610 2610 + })?; 2611 2611 + let codec = tonic::codec::ProstCodec::default(); 2612 2612 + let path = http::uri::PathAndQuery::from_static( 2613 2613 + "/rockbox.v1alpha1.PlaybackService/NextTrack", 2614 2614 + ); 2615 2615 + let mut req = request.into_request(); 2616 2616 + req.extensions_mut() 2617 2617 + .insert( 2618 2618 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "NextTrack"), 2619 2619 + ); 2620 2620 + self.inner.unary(req, path, codec).await 2621 2621 + } 2622 2622 + pub async fn flush_and_reload_tracks( 2623 2623 + &mut self, 2624 2624 + request: impl tonic::IntoRequest<super::FlushAndReloadTracksRequest>, 2625 2625 + ) -> std::result::Result< 2626 2626 + tonic::Response<super::FlushAndReloadTracksResponse>, 2627 2627 + tonic::Status, 2628 2628 + > { 2629 2629 + self.inner 2630 2630 + .ready() 2631 2631 + .await 2632 2632 + .map_err(|e| { 2633 2633 + tonic::Status::unknown( 2634 2634 + format!("Service was not ready: {}", e.into()), 2635 2635 + ) 2636 2636 + })?; 2637 2637 + let codec = tonic::codec::ProstCodec::default(); 2638 2638 + let path = http::uri::PathAndQuery::from_static( 2639 2639 + "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks", 2640 2640 + ); 2641 2641 + let mut req = request.into_request(); 2642 2642 + req.extensions_mut() 2643 2643 + .insert( 2644 2644 + GrpcMethod::new( 2645 2645 + "rockbox.v1alpha1.PlaybackService", 2646 2646 + "FlushAndReloadTracks", 2647 2647 + ), 2648 2648 + ); 2649 2649 + self.inner.unary(req, path, codec).await 2650 2650 + } 2651 2651 + pub async fn get_file_position( 2652 2652 + &mut self, 2653 2653 + request: impl tonic::IntoRequest<super::GetFilePositionRequest>, 2654 2654 + ) -> std::result::Result< 2655 2655 + tonic::Response<super::GetFilePositionResponse>, 2656 2656 + tonic::Status, 2657 2657 + > { 2658 2658 + self.inner 2659 2659 + .ready() 2660 2660 + .await 2661 2661 + .map_err(|e| { 2662 2662 + tonic::Status::unknown( 2663 2663 + format!("Service was not ready: {}", e.into()), 2664 2664 + ) 2665 2665 + })?; 2666 2666 + let codec = tonic::codec::ProstCodec::default(); 2667 2667 + let path = http::uri::PathAndQuery::from_static( 2668 2668 + "/rockbox.v1alpha1.PlaybackService/GetFilePosition", 2669 2669 + ); 2670 2670 + let mut req = request.into_request(); 2671 2671 + req.extensions_mut() 2672 2672 + .insert( 2673 2673 + GrpcMethod::new( 2674 2674 + "rockbox.v1alpha1.PlaybackService", 2675 2675 + "GetFilePosition", 2676 2676 + ), 2677 2677 + ); 2678 2678 + self.inner.unary(req, path, codec).await 2679 2679 + } 2680 2680 + pub async fn hard_stop( 2681 2681 + &mut self, 2682 2682 + request: impl tonic::IntoRequest<super::HardStopRequest>, 2683 2683 + ) -> std::result::Result< 2684 2684 + tonic::Response<super::HardStopResponse>, 2685 2685 + tonic::Status, 2686 2686 + > { 2687 2687 + self.inner 2688 2688 + .ready() 2689 2689 + .await 2690 2690 + .map_err(|e| { 2691 2691 + tonic::Status::unknown( 2692 2692 + format!("Service was not ready: {}", e.into()), 2693 2693 + ) 2694 2694 + })?; 2695 2695 + let codec = tonic::codec::ProstCodec::default(); 2696 2696 + let path = http::uri::PathAndQuery::from_static( 2697 2697 + "/rockbox.v1alpha1.PlaybackService/HardStop", 2698 2698 + ); 2699 2699 + let mut req = request.into_request(); 2700 2700 + req.extensions_mut() 2701 2701 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "HardStop")); 2702 2702 + self.inner.unary(req, path, codec).await 2703 2703 + } 2704 2704 + pub async fn play_album( 2705 2705 + &mut self, 2706 2706 + request: impl tonic::IntoRequest<super::PlayAlbumRequest>, 2707 2707 + ) -> std::result::Result< 2708 2708 + tonic::Response<super::PlayAlbumResponse>, 2709 2709 + tonic::Status, 2710 2710 + > { 2711 2711 + self.inner 2712 2712 + .ready() 2713 2713 + .await 2714 2714 + .map_err(|e| { 2715 2715 + tonic::Status::unknown( 2716 2716 + format!("Service was not ready: {}", e.into()), 2717 2717 + ) 2718 2718 + })?; 2719 2719 + let codec = tonic::codec::ProstCodec::default(); 2720 2720 + let path = http::uri::PathAndQuery::from_static( 2721 2721 + "/rockbox.v1alpha1.PlaybackService/PlayAlbum", 2722 2722 + ); 2723 2723 + let mut req = request.into_request(); 2724 2724 + req.extensions_mut() 2725 2725 + .insert( 2726 2726 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAlbum"), 2727 2727 + ); 2728 2728 + self.inner.unary(req, path, codec).await 2729 2729 + } 2730 2730 + pub async fn play_artist_tracks( 2731 2731 + &mut self, 2732 2732 + request: impl tonic::IntoRequest<super::PlayArtistTracksRequest>, 2733 2733 + ) -> std::result::Result< 2734 2734 + tonic::Response<super::PlayArtistTracksResponse>, 2735 2735 + tonic::Status, 2736 2736 + > { 2737 2737 + self.inner 2738 2738 + .ready() 2739 2739 + .await 2740 2740 + .map_err(|e| { 2741 2741 + tonic::Status::unknown( 2742 2742 + format!("Service was not ready: {}", e.into()), 2743 2743 + ) 2744 2744 + })?; 2745 2745 + let codec = tonic::codec::ProstCodec::default(); 2746 2746 + let path = http::uri::PathAndQuery::from_static( 2747 2747 + "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks", 2748 2748 + ); 2749 2749 + let mut req = request.into_request(); 2750 2750 + req.extensions_mut() 2751 2751 + .insert( 2752 2752 + GrpcMethod::new( 2753 2753 + "rockbox.v1alpha1.PlaybackService", 2754 2754 + "PlayArtistTracks", 2755 2755 + ), 2756 2756 + ); 2757 2757 + self.inner.unary(req, path, codec).await 2758 2758 + } 2759 2759 + pub async fn play_playlist( 2760 2760 + &mut self, 2761 2761 + request: impl tonic::IntoRequest<super::PlayPlaylistRequest>, 2762 2762 + ) -> std::result::Result< 2763 2763 + tonic::Response<super::PlayPlaylistResponse>, 2764 2764 + tonic::Status, 2765 2765 + > { 2766 2766 + self.inner 2767 2767 + .ready() 2768 2768 + .await 2769 2769 + .map_err(|e| { 2770 2770 + tonic::Status::unknown( 2771 2771 + format!("Service was not ready: {}", e.into()), 2772 2772 + ) 2773 2773 + })?; 2774 2774 + let codec = tonic::codec::ProstCodec::default(); 2775 2775 + let path = http::uri::PathAndQuery::from_static( 2776 2776 + "/rockbox.v1alpha1.PlaybackService/PlayPlaylist", 2777 2777 + ); 2778 2778 + let mut req = request.into_request(); 2779 2779 + req.extensions_mut() 2780 2780 + .insert( 2781 2781 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayPlaylist"), 2782 2782 + ); 2783 2783 + self.inner.unary(req, path, codec).await 2784 2784 + } 2785 2785 + pub async fn play_directory( 2786 2786 + &mut self, 2787 2787 + request: impl tonic::IntoRequest<super::PlayDirectoryRequest>, 2788 2788 + ) -> std::result::Result< 2789 2789 + tonic::Response<super::PlayDirectoryResponse>, 2790 2790 + tonic::Status, 2791 2791 + > { 2792 2792 + self.inner 2793 2793 + .ready() 2794 2794 + .await 2795 2795 + .map_err(|e| { 2796 2796 + tonic::Status::unknown( 2797 2797 + format!("Service was not ready: {}", e.into()), 2798 2798 + ) 2799 2799 + })?; 2800 2800 + let codec = tonic::codec::ProstCodec::default(); 2801 2801 + let path = http::uri::PathAndQuery::from_static( 2802 2802 + "/rockbox.v1alpha1.PlaybackService/PlayDirectory", 2803 2803 + ); 2804 2804 + let mut req = request.into_request(); 2805 2805 + req.extensions_mut() 2806 2806 + .insert( 2807 2807 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayDirectory"), 2808 2808 + ); 2809 2809 + self.inner.unary(req, path, codec).await 2810 2810 + } 2811 2811 + pub async fn play_track( 2812 2812 + &mut self, 2813 2813 + request: impl tonic::IntoRequest<super::PlayTrackRequest>, 2814 2814 + ) -> std::result::Result< 2815 2815 + tonic::Response<super::PlayTrackResponse>, 2816 2816 + tonic::Status, 2817 2817 + > { 2818 2818 + self.inner 2819 2819 + .ready() 2820 2820 + .await 2821 2821 + .map_err(|e| { 2822 2822 + tonic::Status::unknown( 2823 2823 + format!("Service was not ready: {}", e.into()), 2824 2824 + ) 2825 2825 + })?; 2826 2826 + let codec = tonic::codec::ProstCodec::default(); 2827 2827 + let path = http::uri::PathAndQuery::from_static( 2828 2828 + "/rockbox.v1alpha1.PlaybackService/PlayTrack", 2829 2829 + ); 2830 2830 + let mut req = request.into_request(); 2831 2831 + req.extensions_mut() 2832 2832 + .insert( 2833 2833 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayTrack"), 2834 2834 + ); 2835 2835 + self.inner.unary(req, path, codec).await 2836 2836 + } 2837 2837 + pub async fn play_liked_tracks( 2838 2838 + &mut self, 2839 2839 + request: impl tonic::IntoRequest<super::PlayLikedTracksRequest>, 2840 2840 + ) -> std::result::Result< 2841 2841 + tonic::Response<super::PlayLikedTracksResponse>, 2842 2842 + tonic::Status, 2843 2843 + > { 2844 2844 + self.inner 2845 2845 + .ready() 2846 2846 + .await 2847 2847 + .map_err(|e| { 2848 2848 + tonic::Status::unknown( 2849 2849 + format!("Service was not ready: {}", e.into()), 2850 2850 + ) 2851 2851 + })?; 2852 2852 + let codec = tonic::codec::ProstCodec::default(); 2853 2853 + let path = http::uri::PathAndQuery::from_static( 2854 2854 + "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks", 2855 2855 + ); 2856 2856 + let mut req = request.into_request(); 2857 2857 + req.extensions_mut() 2858 2858 + .insert( 2859 2859 + GrpcMethod::new( 2860 2860 + "rockbox.v1alpha1.PlaybackService", 2861 2861 + "PlayLikedTracks", 2862 2862 + ), 2863 2863 + ); 2864 2864 + self.inner.unary(req, path, codec).await 2865 2865 + } 2866 2866 + pub async fn play_all_tracks( 2867 2867 + &mut self, 2868 2868 + request: impl tonic::IntoRequest<super::PlayAllTracksRequest>, 2869 2869 + ) -> std::result::Result< 2870 2870 + tonic::Response<super::PlayAllTracksResponse>, 2871 2871 + tonic::Status, 2872 2872 + > { 2873 2873 + self.inner 2874 2874 + .ready() 2875 2875 + .await 2876 2876 + .map_err(|e| { 2877 2877 + tonic::Status::unknown( 2878 2878 + format!("Service was not ready: {}", e.into()), 2879 2879 + ) 2880 2880 + })?; 2881 2881 + let codec = tonic::codec::ProstCodec::default(); 2882 2882 + let path = http::uri::PathAndQuery::from_static( 2883 2883 + "/rockbox.v1alpha1.PlaybackService/PlayAllTracks", 2884 2884 + ); 2885 2885 + let mut req = request.into_request(); 2886 2886 + req.extensions_mut() 2887 2887 + .insert( 2888 2888 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAllTracks"), 2889 2889 + ); 2890 2890 + self.inner.unary(req, path, codec).await 2891 2891 + } 2892 2892 + pub async fn stream_current_track( 2893 2893 + &mut self, 2894 2894 + request: impl tonic::IntoRequest<super::StreamCurrentTrackRequest>, 2895 2895 + ) -> std::result::Result< 2896 2896 + tonic::Response<tonic::codec::Streaming<super::CurrentTrackResponse>>, 2897 2897 + tonic::Status, 2898 2898 + > { 2899 2899 + self.inner 2900 2900 + .ready() 2901 2901 + .await 2902 2902 + .map_err(|e| { 2903 2903 + tonic::Status::unknown( 2904 2904 + format!("Service was not ready: {}", e.into()), 2905 2905 + ) 2906 2906 + })?; 2907 2907 + let codec = tonic::codec::ProstCodec::default(); 2908 2908 + let path = http::uri::PathAndQuery::from_static( 2909 2909 + "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack", 2910 2910 + ); 2911 2911 + let mut req = request.into_request(); 2912 2912 + req.extensions_mut() 2913 2913 + .insert( 2914 2914 + GrpcMethod::new( 2915 2915 + "rockbox.v1alpha1.PlaybackService", 2916 2916 + "StreamCurrentTrack", 2917 2917 + ), 2918 2918 + ); 2919 2919 + self.inner.server_streaming(req, path, codec).await 2920 2920 + } 2921 2921 + pub async fn stream_status( 2922 2922 + &mut self, 2923 2923 + request: impl tonic::IntoRequest<super::StreamStatusRequest>, 2924 2924 + ) -> std::result::Result< 2925 2925 + tonic::Response<tonic::codec::Streaming<super::StatusResponse>>, 2926 2926 + tonic::Status, 2927 2927 + > { 2928 2928 + self.inner 2929 2929 + .ready() 2930 2930 + .await 2931 2931 + .map_err(|e| { 2932 2932 + tonic::Status::unknown( 2933 2933 + format!("Service was not ready: {}", e.into()), 2934 2934 + ) 2935 2935 + })?; 2936 2936 + let codec = tonic::codec::ProstCodec::default(); 2937 2937 + let path = http::uri::PathAndQuery::from_static( 2938 2938 + "/rockbox.v1alpha1.PlaybackService/StreamStatus", 2939 2939 + ); 2940 2940 + let mut req = request.into_request(); 2941 2941 + req.extensions_mut() 2942 2942 + .insert( 2943 2943 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamStatus"), 2944 2944 + ); 2945 2945 + self.inner.server_streaming(req, path, codec).await 2946 2946 + } 2947 2947 + pub async fn stream_playlist( 2948 2948 + &mut self, 2949 2949 + request: impl tonic::IntoRequest<super::StreamPlaylistRequest>, 2950 2950 + ) -> std::result::Result< 2951 2951 + tonic::Response<tonic::codec::Streaming<super::PlaylistResponse>>, 2952 2952 + tonic::Status, 2953 2953 + > { 2954 2954 + self.inner 2955 2955 + .ready() 2956 2956 + .await 2957 2957 + .map_err(|e| { 2958 2958 + tonic::Status::unknown( 2959 2959 + format!("Service was not ready: {}", e.into()), 2960 2960 + ) 2961 2961 + })?; 2962 2962 + let codec = tonic::codec::ProstCodec::default(); 2963 2963 + let path = http::uri::PathAndQuery::from_static( 2964 2964 + "/rockbox.v1alpha1.PlaybackService/StreamPlaylist", 2965 2965 + ); 2966 2966 + let mut req = request.into_request(); 2967 2967 + req.extensions_mut() 2968 2968 + .insert( 2969 2969 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamPlaylist"), 2970 2970 + ); 2971 2971 + self.inner.server_streaming(req, path, codec).await 2972 2972 + } 2973 2973 + } 2974 2974 + } 2975 2975 + /// Generated server implementations. 2976 2976 + pub mod playback_service_server { 2977 2977 + #![allow( 2978 2978 + unused_variables, 2979 2979 + dead_code, 2980 2980 + missing_docs, 2981 2981 + clippy::wildcard_imports, 2982 2982 + clippy::let_unit_value, 2983 2983 + )] 2984 2984 + use tonic::codegen::*; 2985 2985 + /// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer. 2986 2986 + #[async_trait] 2987 2987 + pub trait PlaybackService: std::marker::Send + std::marker::Sync + 'static { 2988 2988 + async fn play( 2989 2989 + &self, 2990 2990 + request: tonic::Request<super::PlayRequest>, 2991 2991 + ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status>; 2992 2992 + async fn pause( 2993 2993 + &self, 2994 2994 + request: tonic::Request<super::PauseRequest>, 2995 2995 + ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status>; 2996 2996 + async fn play_or_pause( 2997 2997 + &self, 2998 2998 + request: tonic::Request<super::PlayOrPauseRequest>, 2999 2999 + ) -> std::result::Result< 3000 3000 + tonic::Response<super::PlayOrPauseResponse>, 3001 3001 + tonic::Status, 3002 3002 + >; 3003 3003 + async fn resume( 3004 3004 + &self, 3005 3005 + request: tonic::Request<super::ResumeRequest>, 3006 3006 + ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status>; 3007 3007 + async fn next( 3008 3008 + &self, 3009 3009 + request: tonic::Request<super::NextRequest>, 3010 3010 + ) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status>; 3011 3011 + async fn previous( 3012 3012 + &self, 3013 3013 + request: tonic::Request<super::PreviousRequest>, 3014 3014 + ) -> std::result::Result< 3015 3015 + tonic::Response<super::PreviousResponse>, 3016 3016 + tonic::Status, 3017 3017 + >; 3018 3018 + async fn fast_forward_rewind( 3019 3019 + &self, 3020 3020 + request: tonic::Request<super::FastForwardRewindRequest>, 3021 3021 + ) -> std::result::Result< 3022 3022 + tonic::Response<super::FastForwardRewindResponse>, 3023 3023 + tonic::Status, 3024 3024 + >; 3025 3025 + async fn status( 3026 3026 + &self, 3027 3027 + request: tonic::Request<super::StatusRequest>, 3028 3028 + ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status>; 3029 3029 + async fn current_track( 3030 3030 + &self, 3031 3031 + request: tonic::Request<super::CurrentTrackRequest>, 3032 3032 + ) -> std::result::Result< 3033 3033 + tonic::Response<super::CurrentTrackResponse>, 3034 3034 + tonic::Status, 3035 3035 + >; 3036 3036 + async fn next_track( 3037 3037 + &self, 3038 3038 + request: tonic::Request<super::NextTrackRequest>, 3039 3039 + ) -> std::result::Result< 3040 3040 + tonic::Response<super::NextTrackResponse>, 3041 3041 + tonic::Status, 3042 3042 + >; 3043 3043 + async fn flush_and_reload_tracks( 3044 3044 + &self, 3045 3045 + request: tonic::Request<super::FlushAndReloadTracksRequest>, 3046 3046 + ) -> std::result::Result< 3047 3047 + tonic::Response<super::FlushAndReloadTracksResponse>, 3048 3048 + tonic::Status, 3049 3049 + >; 3050 3050 + async fn get_file_position( 3051 3051 + &self, 3052 3052 + request: tonic::Request<super::GetFilePositionRequest>, 3053 3053 + ) -> std::result::Result< 3054 3054 + tonic::Response<super::GetFilePositionResponse>, 3055 3055 + tonic::Status, 3056 3056 + >; 3057 3057 + async fn hard_stop( 3058 3058 + &self, 3059 3059 + request: tonic::Request<super::HardStopRequest>, 3060 3060 + ) -> std::result::Result< 3061 3061 + tonic::Response<super::HardStopResponse>, 3062 3062 + tonic::Status, 3063 3063 + >; 3064 3064 + async fn play_album( 3065 3065 + &self, 3066 3066 + request: tonic::Request<super::PlayAlbumRequest>, 3067 3067 + ) -> std::result::Result< 3068 3068 + tonic::Response<super::PlayAlbumResponse>, 3069 3069 + tonic::Status, 3070 3070 + >; 3071 3071 + async fn play_artist_tracks( 3072 3072 + &self, 3073 3073 + request: tonic::Request<super::PlayArtistTracksRequest>, 3074 3074 + ) -> std::result::Result< 3075 3075 + tonic::Response<super::PlayArtistTracksResponse>, 3076 3076 + tonic::Status, 3077 3077 + >; 3078 3078 + async fn play_playlist( 3079 3079 + &self, 3080 3080 + request: tonic::Request<super::PlayPlaylistRequest>, 3081 3081 + ) -> std::result::Result< 3082 3082 + tonic::Response<super::PlayPlaylistResponse>, 3083 3083 + tonic::Status, 3084 3084 + >; 3085 3085 + async fn play_directory( 3086 3086 + &self, 3087 3087 + request: tonic::Request<super::PlayDirectoryRequest>, 3088 3088 + ) -> std::result::Result< 3089 3089 + tonic::Response<super::PlayDirectoryResponse>, 3090 3090 + tonic::Status, 3091 3091 + >; 3092 3092 + async fn play_track( 3093 3093 + &self, 3094 3094 + request: tonic::Request<super::PlayTrackRequest>, 3095 3095 + ) -> std::result::Result< 3096 3096 + tonic::Response<super::PlayTrackResponse>, 3097 3097 + tonic::Status, 3098 3098 + >; 3099 3099 + async fn play_liked_tracks( 3100 3100 + &self, 3101 3101 + request: tonic::Request<super::PlayLikedTracksRequest>, 3102 3102 + ) -> std::result::Result< 3103 3103 + tonic::Response<super::PlayLikedTracksResponse>, 3104 3104 + tonic::Status, 3105 3105 + >; 3106 3106 + async fn play_all_tracks( 3107 3107 + &self, 3108 3108 + request: tonic::Request<super::PlayAllTracksRequest>, 3109 3109 + ) -> std::result::Result< 3110 3110 + tonic::Response<super::PlayAllTracksResponse>, 3111 3111 + tonic::Status, 3112 3112 + >; 3113 3113 + /// Server streaming response type for the StreamCurrentTrack method. 3114 3114 + type StreamCurrentTrackStream: tonic::codegen::tokio_stream::Stream< 3115 3115 + Item = std::result::Result<super::CurrentTrackResponse, tonic::Status>, 3116 3116 + > 3117 3117 + + std::marker::Send 3118 3118 + + 'static; 3119 3119 + async fn stream_current_track( 3120 3120 + &self, 3121 3121 + request: tonic::Request<super::StreamCurrentTrackRequest>, 3122 3122 + ) -> std::result::Result< 3123 3123 + tonic::Response<Self::StreamCurrentTrackStream>, 3124 3124 + tonic::Status, 3125 3125 + >; 3126 3126 + /// Server streaming response type for the StreamStatus method. 3127 3127 + type StreamStatusStream: tonic::codegen::tokio_stream::Stream< 3128 3128 + Item = std::result::Result<super::StatusResponse, tonic::Status>, 3129 3129 + > 3130 3130 + + std::marker::Send 3131 3131 + + 'static; 3132 3132 + async fn stream_status( 3133 3133 + &self, 3134 3134 + request: tonic::Request<super::StreamStatusRequest>, 3135 3135 + ) -> std::result::Result< 3136 3136 + tonic::Response<Self::StreamStatusStream>, 3137 3137 + tonic::Status, 3138 3138 + >; 3139 3139 + /// Server streaming response type for the StreamPlaylist method. 3140 3140 + type StreamPlaylistStream: tonic::codegen::tokio_stream::Stream< 3141 3141 + Item = std::result::Result<super::PlaylistResponse, tonic::Status>, 3142 3142 + > 3143 3143 + + std::marker::Send 3144 3144 + + 'static; 3145 3145 + async fn stream_playlist( 3146 3146 + &self, 3147 3147 + request: tonic::Request<super::StreamPlaylistRequest>, 3148 3148 + ) -> std::result::Result< 3149 3149 + tonic::Response<Self::StreamPlaylistStream>, 3150 3150 + tonic::Status, 3151 3151 + >; 3152 3152 + } 3153 3153 + #[derive(Debug)] 3154 3154 + pub struct PlaybackServiceServer<T> { 3155 3155 + inner: Arc<T>, 3156 3156 + accept_compression_encodings: EnabledCompressionEncodings, 3157 3157 + send_compression_encodings: EnabledCompressionEncodings, 3158 3158 + max_decoding_message_size: Option<usize>, 3159 3159 + max_encoding_message_size: Option<usize>, 3160 3160 + } 3161 3161 + impl<T> PlaybackServiceServer<T> { 3162 3162 + pub fn new(inner: T) -> Self { 3163 3163 + Self::from_arc(Arc::new(inner)) 3164 3164 + } 3165 3165 + pub fn from_arc(inner: Arc<T>) -> Self { 3166 3166 + Self { 3167 3167 + inner, 3168 3168 + accept_compression_encodings: Default::default(), 3169 3169 + send_compression_encodings: Default::default(), 3170 3170 + max_decoding_message_size: None, 3171 3171 + max_encoding_message_size: None, 3172 3172 + } 3173 3173 + } 3174 3174 + pub fn with_interceptor<F>( 3175 3175 + inner: T, 3176 3176 + interceptor: F, 3177 3177 + ) -> InterceptedService<Self, F> 3178 3178 + where 3179 3179 + F: tonic::service::Interceptor, 3180 3180 + { 3181 3181 + InterceptedService::new(Self::new(inner), interceptor) 3182 3182 + } 3183 3183 + /// Enable decompressing requests with the given encoding. 3184 3184 + #[must_use] 3185 3185 + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { 3186 3186 + self.accept_compression_encodings.enable(encoding); 3187 3187 + self 3188 3188 + } 3189 3189 + /// Compress responses with the given encoding, if the client supports it. 3190 3190 + #[must_use] 3191 3191 + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { 3192 3192 + self.send_compression_encodings.enable(encoding); 3193 3193 + self 3194 3194 + } 3195 3195 + /// Limits the maximum size of a decoded message. 3196 3196 + /// 3197 3197 + /// Default: `4MB` 3198 3198 + #[must_use] 3199 3199 + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { 3200 3200 + self.max_decoding_message_size = Some(limit); 3201 3201 + self 3202 3202 + } 3203 3203 + /// Limits the maximum size of an encoded message. 3204 3204 + /// 3205 3205 + /// Default: `usize::MAX` 3206 3206 + #[must_use] 3207 3207 + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { 3208 3208 + self.max_encoding_message_size = Some(limit); 3209 3209 + self 3210 3210 + } 3211 3211 + } 3212 3212 + impl<T, B> tonic::codegen::Service<http::Request<B>> for PlaybackServiceServer<T> 3213 3213 + where 3214 3214 + T: PlaybackService, 3215 3215 + B: Body + std::marker::Send + 'static, 3216 3216 + B::Error: Into<StdError> + std::marker::Send + 'static, 3217 3217 + { 3218 3218 + type Response = http::Response<tonic::body::BoxBody>; 3219 3219 + type Error = std::convert::Infallible; 3220 3220 + type Future = BoxFuture<Self::Response, Self::Error>; 3221 3221 + fn poll_ready( 3222 3222 + &mut self, 3223 3223 + _cx: &mut Context<'_>, 3224 3224 + ) -> Poll<std::result::Result<(), Self::Error>> { 3225 3225 + Poll::Ready(Ok(())) 3226 3226 + } 3227 3227 + fn call(&mut self, req: http::Request<B>) -> Self::Future { 3228 3228 + match req.uri().path() { 3229 3229 + "/rockbox.v1alpha1.PlaybackService/Play" => { 3230 3230 + #[allow(non_camel_case_types)] 3231 3231 + struct PlaySvc<T: PlaybackService>(pub Arc<T>); 3232 3232 + impl< 3233 3233 + T: PlaybackService, 3234 3234 + > tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 3235 3235 + type Response = super::PlayResponse; 3236 3236 + type Future = BoxFuture< 3237 3237 + tonic::Response<Self::Response>, 3238 3238 + tonic::Status, 3239 3239 + >; 3240 3240 + fn call( 3241 3241 + &mut self, 3242 3242 + request: tonic::Request<super::PlayRequest>, 3243 3243 + ) -> Self::Future { 3244 3244 + let inner = Arc::clone(&self.0); 3245 3245 + let fut = async move { 3246 3246 + <T as PlaybackService>::play(&inner, request).await 3247 3247 + }; 3248 3248 + Box::pin(fut) 3249 3249 + } 3250 3250 + } 3251 3251 + let accept_compression_encodings = self.accept_compression_encodings; 3252 3252 + let send_compression_encodings = self.send_compression_encodings; 3253 3253 + let max_decoding_message_size = self.max_decoding_message_size; 3254 3254 + let max_encoding_message_size = self.max_encoding_message_size; 3255 3255 + let inner = self.inner.clone(); 3256 3256 + let fut = async move { 3257 3257 + let method = PlaySvc(inner); 3258 3258 + let codec = tonic::codec::ProstCodec::default(); 3259 3259 + let mut grpc = tonic::server::Grpc::new(codec) 3260 3260 + .apply_compression_config( 3261 3261 + accept_compression_encodings, 3262 3262 + send_compression_encodings, 3263 3263 + ) 3264 3264 + .apply_max_message_size_config( 3265 3265 + max_decoding_message_size, 3266 3266 + max_encoding_message_size, 3267 3267 + ); 3268 3268 + let res = grpc.unary(method, req).await; 3269 3269 + Ok(res) 3270 3270 + }; 3271 3271 + Box::pin(fut) 3272 3272 + } 3273 3273 + "/rockbox.v1alpha1.PlaybackService/Pause" => { 3274 3274 + #[allow(non_camel_case_types)] 3275 3275 + struct PauseSvc<T: PlaybackService>(pub Arc<T>); 3276 3276 + impl< 3277 3277 + T: PlaybackService, 3278 3278 + > tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 3279 3279 + type Response = super::PauseResponse; 3280 3280 + type Future = BoxFuture< 3281 3281 + tonic::Response<Self::Response>, 3282 3282 + tonic::Status, 3283 3283 + >; 3284 3284 + fn call( 3285 3285 + &mut self, 3286 3286 + request: tonic::Request<super::PauseRequest>, 3287 3287 + ) -> Self::Future { 3288 3288 + let inner = Arc::clone(&self.0); 3289 3289 + let fut = async move { 3290 3290 + <T as PlaybackService>::pause(&inner, request).await 3291 3291 + }; 3292 3292 + Box::pin(fut) 3293 3293 + } 3294 3294 + } 3295 3295 + let accept_compression_encodings = self.accept_compression_encodings; 3296 3296 + let send_compression_encodings = self.send_compression_encodings; 3297 3297 + let max_decoding_message_size = self.max_decoding_message_size; 3298 3298 + let max_encoding_message_size = self.max_encoding_message_size; 3299 3299 + let inner = self.inner.clone(); 3300 3300 + let fut = async move { 3301 3301 + let method = PauseSvc(inner); 3302 3302 + let codec = tonic::codec::ProstCodec::default(); 3303 3303 + let mut grpc = tonic::server::Grpc::new(codec) 3304 3304 + .apply_compression_config( 3305 3305 + accept_compression_encodings, 3306 3306 + send_compression_encodings, 3307 3307 + ) 3308 3308 + .apply_max_message_size_config( 3309 3309 + max_decoding_message_size, 3310 3310 + max_encoding_message_size, 3311 3311 + ); 3312 3312 + let res = grpc.unary(method, req).await; 3313 3313 + Ok(res) 3314 3314 + }; 3315 3315 + Box::pin(fut) 3316 3316 + } 3317 3317 + "/rockbox.v1alpha1.PlaybackService/PlayOrPause" => { 3318 3318 + #[allow(non_camel_case_types)] 3319 3319 + struct PlayOrPauseSvc<T: PlaybackService>(pub Arc<T>); 3320 3320 + impl< 3321 3321 + T: PlaybackService, 3322 3322 + > tonic::server::UnaryService<super::PlayOrPauseRequest> 3323 3323 + for PlayOrPauseSvc<T> { 3324 3324 + type Response = super::PlayOrPauseResponse; 3325 3325 + type Future = BoxFuture< 3326 3326 + tonic::Response<Self::Response>, 3327 3327 + tonic::Status, 3328 3328 + >; 3329 3329 + fn call( 3330 3330 + &mut self, 3331 3331 + request: tonic::Request<super::PlayOrPauseRequest>, 3332 3332 + ) -> Self::Future { 3333 3333 + let inner = Arc::clone(&self.0); 3334 3334 + let fut = async move { 3335 3335 + <T as PlaybackService>::play_or_pause(&inner, request).await 3336 3336 + }; 3337 3337 + Box::pin(fut) 3338 3338 + } 3339 3339 + } 3340 3340 + let accept_compression_encodings = self.accept_compression_encodings; 3341 3341 + let send_compression_encodings = self.send_compression_encodings; 3342 3342 + let max_decoding_message_size = self.max_decoding_message_size; 3343 3343 + let max_encoding_message_size = self.max_encoding_message_size; 3344 3344 + let inner = self.inner.clone(); 3345 3345 + let fut = async move { 3346 3346 + let method = PlayOrPauseSvc(inner); 3347 3347 + let codec = tonic::codec::ProstCodec::default(); 3348 3348 + let mut grpc = tonic::server::Grpc::new(codec) 3349 3349 + .apply_compression_config( 3350 3350 + accept_compression_encodings, 3351 3351 + send_compression_encodings, 3352 3352 + ) 3353 3353 + .apply_max_message_size_config( 3354 3354 + max_decoding_message_size, 3355 3355 + max_encoding_message_size, 3356 3356 + ); 3357 3357 + let res = grpc.unary(method, req).await; 3358 3358 + Ok(res) 3359 3359 + }; 3360 3360 + Box::pin(fut) 3361 3361 + } 3362 3362 + "/rockbox.v1alpha1.PlaybackService/Resume" => { 3363 3363 + #[allow(non_camel_case_types)] 3364 3364 + struct ResumeSvc<T: PlaybackService>(pub Arc<T>); 3365 3365 + impl< 3366 3366 + T: PlaybackService, 3367 3367 + > tonic::server::UnaryService<super::ResumeRequest> 3368 3368 + for ResumeSvc<T> { 3369 3369 + type Response = super::ResumeResponse; 3370 3370 + type Future = BoxFuture< 3371 3371 + tonic::Response<Self::Response>, 3372 3372 + tonic::Status, 3373 3373 + >; 3374 3374 + fn call( 3375 3375 + &mut self, 3376 3376 + request: tonic::Request<super::ResumeRequest>, 3377 3377 + ) -> Self::Future { 3378 3378 + let inner = Arc::clone(&self.0); 3379 3379 + let fut = async move { 3380 3380 + <T as PlaybackService>::resume(&inner, request).await 3381 3381 + }; 3382 3382 + Box::pin(fut) 3383 3383 + } 3384 3384 + } 3385 3385 + let accept_compression_encodings = self.accept_compression_encodings; 3386 3386 + let send_compression_encodings = self.send_compression_encodings; 3387 3387 + let max_decoding_message_size = self.max_decoding_message_size; 3388 3388 + let max_encoding_message_size = self.max_encoding_message_size; 3389 3389 + let inner = self.inner.clone(); 3390 3390 + let fut = async move { 3391 3391 + let method = ResumeSvc(inner); 3392 3392 + let codec = tonic::codec::ProstCodec::default(); 3393 3393 + let mut grpc = tonic::server::Grpc::new(codec) 3394 3394 + .apply_compression_config( 3395 3395 + accept_compression_encodings, 3396 3396 + send_compression_encodings, 3397 3397 + ) 3398 3398 + .apply_max_message_size_config( 3399 3399 + max_decoding_message_size, 3400 3400 + max_encoding_message_size, 3401 3401 + ); 3402 3402 + let res = grpc.unary(method, req).await; 3403 3403 + Ok(res) 3404 3404 + }; 3405 3405 + Box::pin(fut) 3406 3406 + } 3407 3407 + "/rockbox.v1alpha1.PlaybackService/Next" => { 3408 3408 + #[allow(non_camel_case_types)] 3409 3409 + struct NextSvc<T: PlaybackService>(pub Arc<T>); 3410 3410 + impl< 3411 3411 + T: PlaybackService, 3412 3412 + > tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 3413 3413 + type Response = super::NextResponse; 3414 3414 + type Future = BoxFuture< 3415 3415 + tonic::Response<Self::Response>, 3416 3416 + tonic::Status, 3417 3417 + >; 3418 3418 + fn call( 3419 3419 + &mut self, 3420 3420 + request: tonic::Request<super::NextRequest>, 3421 3421 + ) -> Self::Future { 3422 3422 + let inner = Arc::clone(&self.0); 3423 3423 + let fut = async move { 3424 3424 + <T as PlaybackService>::next(&inner, request).await 3425 3425 + }; 3426 3426 + Box::pin(fut) 3427 3427 + } 3428 3428 + } 3429 3429 + let accept_compression_encodings = self.accept_compression_encodings; 3430 3430 + let send_compression_encodings = self.send_compression_encodings; 3431 3431 + let max_decoding_message_size = self.max_decoding_message_size; 3432 3432 + let max_encoding_message_size = self.max_encoding_message_size; 3433 3433 + let inner = self.inner.clone(); 3434 3434 + let fut = async move { 3435 3435 + let method = NextSvc(inner); 3436 3436 + let codec = tonic::codec::ProstCodec::default(); 3437 3437 + let mut grpc = tonic::server::Grpc::new(codec) 3438 3438 + .apply_compression_config( 3439 3439 + accept_compression_encodings, 3440 3440 + send_compression_encodings, 3441 3441 + ) 3442 3442 + .apply_max_message_size_config( 3443 3443 + max_decoding_message_size, 3444 3444 + max_encoding_message_size, 3445 3445 + ); 3446 3446 + let res = grpc.unary(method, req).await; 3447 3447 + Ok(res) 3448 3448 + }; 3449 3449 + Box::pin(fut) 3450 3450 + } 3451 3451 + "/rockbox.v1alpha1.PlaybackService/Previous" => { 3452 3452 + #[allow(non_camel_case_types)] 3453 3453 + struct PreviousSvc<T: PlaybackService>(pub Arc<T>); 3454 3454 + impl< 3455 3455 + T: PlaybackService, 3456 3456 + > tonic::server::UnaryService<super::PreviousRequest> 3457 3457 + for PreviousSvc<T> { 3458 3458 + type Response = super::PreviousResponse; 3459 3459 + type Future = BoxFuture< 3460 3460 + tonic::Response<Self::Response>, 3461 3461 + tonic::Status, 3462 3462 + >; 3463 3463 + fn call( 3464 3464 + &mut self, 3465 3465 + request: tonic::Request<super::PreviousRequest>, 3466 3466 + ) -> Self::Future { 3467 3467 + let inner = Arc::clone(&self.0); 3468 3468 + let fut = async move { 3469 3469 + <T as PlaybackService>::previous(&inner, request).await 3470 3470 + }; 3471 3471 + Box::pin(fut) 3472 3472 + } 3473 3473 + } 3474 3474 + let accept_compression_encodings = self.accept_compression_encodings; 3475 3475 + let send_compression_encodings = self.send_compression_encodings; 3476 3476 + let max_decoding_message_size = self.max_decoding_message_size; 3477 3477 + let max_encoding_message_size = self.max_encoding_message_size; 3478 3478 + let inner = self.inner.clone(); 3479 3479 + let fut = async move { 3480 3480 + let method = PreviousSvc(inner); 3481 3481 + let codec = tonic::codec::ProstCodec::default(); 3482 3482 + let mut grpc = tonic::server::Grpc::new(codec) 3483 3483 + .apply_compression_config( 3484 3484 + accept_compression_encodings, 3485 3485 + send_compression_encodings, 3486 3486 + ) 3487 3487 + .apply_max_message_size_config( 3488 3488 + max_decoding_message_size, 3489 3489 + max_encoding_message_size, 3490 3490 + ); 3491 3491 + let res = grpc.unary(method, req).await; 3492 3492 + Ok(res) 3493 3493 + }; 3494 3494 + Box::pin(fut) 3495 3495 + } 3496 3496 + "/rockbox.v1alpha1.PlaybackService/FastForwardRewind" => { 3497 3497 + #[allow(non_camel_case_types)] 3498 3498 + struct FastForwardRewindSvc<T: PlaybackService>(pub Arc<T>); 3499 3499 + impl< 3500 3500 + T: PlaybackService, 3501 3501 + > tonic::server::UnaryService<super::FastForwardRewindRequest> 3502 3502 + for FastForwardRewindSvc<T> { 3503 3503 + type Response = super::FastForwardRewindResponse; 3504 3504 + type Future = BoxFuture< 3505 3505 + tonic::Response<Self::Response>, 3506 3506 + tonic::Status, 3507 3507 + >; 3508 3508 + fn call( 3509 3509 + &mut self, 3510 3510 + request: tonic::Request<super::FastForwardRewindRequest>, 3511 3511 + ) -> Self::Future { 3512 3512 + let inner = Arc::clone(&self.0); 3513 3513 + let fut = async move { 3514 3514 + <T as PlaybackService>::fast_forward_rewind(&inner, request) 3515 3515 + .await 3516 3516 + }; 3517 3517 + Box::pin(fut) 3518 3518 + } 3519 3519 + } 3520 3520 + let accept_compression_encodings = self.accept_compression_encodings; 3521 3521 + let send_compression_encodings = self.send_compression_encodings; 3522 3522 + let max_decoding_message_size = self.max_decoding_message_size; 3523 3523 + let max_encoding_message_size = self.max_encoding_message_size; 3524 3524 + let inner = self.inner.clone(); 3525 3525 + let fut = async move { 3526 3526 + let method = FastForwardRewindSvc(inner); 3527 3527 + let codec = tonic::codec::ProstCodec::default(); 3528 3528 + let mut grpc = tonic::server::Grpc::new(codec) 3529 3529 + .apply_compression_config( 3530 3530 + accept_compression_encodings, 3531 3531 + send_compression_encodings, 3532 3532 + ) 3533 3533 + .apply_max_message_size_config( 3534 3534 + max_decoding_message_size, 3535 3535 + max_encoding_message_size, 3536 3536 + ); 3537 3537 + let res = grpc.unary(method, req).await; 3538 3538 + Ok(res) 3539 3539 + }; 3540 3540 + Box::pin(fut) 3541 3541 + } 3542 3542 + "/rockbox.v1alpha1.PlaybackService/Status" => { 3543 3543 + #[allow(non_camel_case_types)] 3544 3544 + struct StatusSvc<T: PlaybackService>(pub Arc<T>); 3545 3545 + impl< 3546 3546 + T: PlaybackService, 3547 3547 + > tonic::server::UnaryService<super::StatusRequest> 3548 3548 + for StatusSvc<T> { 3549 3549 + type Response = super::StatusResponse; 3550 3550 + type Future = BoxFuture< 3551 3551 + tonic::Response<Self::Response>, 3552 3552 + tonic::Status, 3553 3553 + >; 3554 3554 + fn call( 3555 3555 + &mut self, 3556 3556 + request: tonic::Request<super::StatusRequest>, 3557 3557 + ) -> Self::Future { 3558 3558 + let inner = Arc::clone(&self.0); 3559 3559 + let fut = async move { 3560 3560 + <T as PlaybackService>::status(&inner, request).await 3561 3561 + }; 3562 3562 + Box::pin(fut) 3563 3563 + } 3564 3564 + } 3565 3565 + let accept_compression_encodings = self.accept_compression_encodings; 3566 3566 + let send_compression_encodings = self.send_compression_encodings; 3567 3567 + let max_decoding_message_size = self.max_decoding_message_size; 3568 3568 + let max_encoding_message_size = self.max_encoding_message_size; 3569 3569 + let inner = self.inner.clone(); 3570 3570 + let fut = async move { 3571 3571 + let method = StatusSvc(inner); 3572 3572 + let codec = tonic::codec::ProstCodec::default(); 3573 3573 + let mut grpc = tonic::server::Grpc::new(codec) 3574 3574 + .apply_compression_config( 3575 3575 + accept_compression_encodings, 3576 3576 + send_compression_encodings, 3577 3577 + ) 3578 3578 + .apply_max_message_size_config( 3579 3579 + max_decoding_message_size, 3580 3580 + max_encoding_message_size, 3581 3581 + ); 3582 3582 + let res = grpc.unary(method, req).await; 3583 3583 + Ok(res) 3584 3584 + }; 3585 3585 + Box::pin(fut) 3586 3586 + } 3587 3587 + "/rockbox.v1alpha1.PlaybackService/CurrentTrack" => { 3588 3588 + #[allow(non_camel_case_types)] 3589 3589 + struct CurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 3590 3590 + impl< 3591 3591 + T: PlaybackService, 3592 3592 + > tonic::server::UnaryService<super::CurrentTrackRequest> 3593 3593 + for CurrentTrackSvc<T> { 3594 3594 + type Response = super::CurrentTrackResponse; 3595 3595 + type Future = BoxFuture< 3596 3596 + tonic::Response<Self::Response>, 3597 3597 + tonic::Status, 3598 3598 + >; 3599 3599 + fn call( 3600 3600 + &mut self, 3601 3601 + request: tonic::Request<super::CurrentTrackRequest>, 3602 3602 + ) -> Self::Future { 3603 3603 + let inner = Arc::clone(&self.0); 3604 3604 + let fut = async move { 3605 3605 + <T as PlaybackService>::current_track(&inner, request).await 3606 3606 + }; 3607 3607 + Box::pin(fut) 3608 3608 + } 3609 3609 + } 3610 3610 + let accept_compression_encodings = self.accept_compression_encodings; 3611 3611 + let send_compression_encodings = self.send_compression_encodings; 3612 3612 + let max_decoding_message_size = self.max_decoding_message_size; 3613 3613 + let max_encoding_message_size = self.max_encoding_message_size; 3614 3614 + let inner = self.inner.clone(); 3615 3615 + let fut = async move { 3616 3616 + let method = CurrentTrackSvc(inner); 3617 3617 + let codec = tonic::codec::ProstCodec::default(); 3618 3618 + let mut grpc = tonic::server::Grpc::new(codec) 3619 3619 + .apply_compression_config( 3620 3620 + accept_compression_encodings, 3621 3621 + send_compression_encodings, 3622 3622 + ) 3623 3623 + .apply_max_message_size_config( 3624 3624 + max_decoding_message_size, 3625 3625 + max_encoding_message_size, 3626 3626 + ); 3627 3627 + let res = grpc.unary(method, req).await; 3628 3628 + Ok(res) 3629 3629 + }; 3630 3630 + Box::pin(fut) 3631 3631 + } 3632 3632 + "/rockbox.v1alpha1.PlaybackService/NextTrack" => { 3633 3633 + #[allow(non_camel_case_types)] 3634 3634 + struct NextTrackSvc<T: PlaybackService>(pub Arc<T>); 3635 3635 + impl< 3636 3636 + T: PlaybackService, 3637 3637 + > tonic::server::UnaryService<super::NextTrackRequest> 3638 3638 + for NextTrackSvc<T> { 3639 3639 + type Response = super::NextTrackResponse; 3640 3640 + type Future = BoxFuture< 3641 3641 + tonic::Response<Self::Response>, 3642 3642 + tonic::Status, 3643 3643 + >; 3644 3644 + fn call( 3645 3645 + &mut self, 3646 3646 + request: tonic::Request<super::NextTrackRequest>, 3647 3647 + ) -> Self::Future { 3648 3648 + let inner = Arc::clone(&self.0); 3649 3649 + let fut = async move { 3650 3650 + <T as PlaybackService>::next_track(&inner, request).await 3651 3651 + }; 3652 3652 + Box::pin(fut) 3653 3653 + } 3654 3654 + } 3655 3655 + let accept_compression_encodings = self.accept_compression_encodings; 3656 3656 + let send_compression_encodings = self.send_compression_encodings; 3657 3657 + let max_decoding_message_size = self.max_decoding_message_size; 3658 3658 + let max_encoding_message_size = self.max_encoding_message_size; 3659 3659 + let inner = self.inner.clone(); 3660 3660 + let fut = async move { 3661 3661 + let method = NextTrackSvc(inner); 3662 3662 + let codec = tonic::codec::ProstCodec::default(); 3663 3663 + let mut grpc = tonic::server::Grpc::new(codec) 3664 3664 + .apply_compression_config( 3665 3665 + accept_compression_encodings, 3666 3666 + send_compression_encodings, 3667 3667 + ) 3668 3668 + .apply_max_message_size_config( 3669 3669 + max_decoding_message_size, 3670 3670 + max_encoding_message_size, 3671 3671 + ); 3672 3672 + let res = grpc.unary(method, req).await; 3673 3673 + Ok(res) 3674 3674 + }; 3675 3675 + Box::pin(fut) 3676 3676 + } 3677 3677 + "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks" => { 3678 3678 + #[allow(non_camel_case_types)] 3679 3679 + struct FlushAndReloadTracksSvc<T: PlaybackService>(pub Arc<T>); 3680 3680 + impl< 3681 3681 + T: PlaybackService, 3682 3682 + > tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3683 3683 + for FlushAndReloadTracksSvc<T> { 3684 3684 + type Response = super::FlushAndReloadTracksResponse; 3685 3685 + type Future = BoxFuture< 3686 3686 + tonic::Response<Self::Response>, 3687 3687 + tonic::Status, 3688 3688 + >; 3689 3689 + fn call( 3690 3690 + &mut self, 3691 3691 + request: tonic::Request<super::FlushAndReloadTracksRequest>, 3692 3692 + ) -> Self::Future { 3693 3693 + let inner = Arc::clone(&self.0); 3694 3694 + let fut = async move { 3695 3695 + <T as PlaybackService>::flush_and_reload_tracks( 3696 3696 + &inner, 3697 3697 + request, 3698 3698 + ) 3699 3699 + .await 3700 3700 + }; 3701 3701 + Box::pin(fut) 3702 3702 + } 3703 3703 + } 3704 3704 + let accept_compression_encodings = self.accept_compression_encodings; 3705 3705 + let send_compression_encodings = self.send_compression_encodings; 3706 3706 + let max_decoding_message_size = self.max_decoding_message_size; 3707 3707 + let max_encoding_message_size = self.max_encoding_message_size; 3708 3708 + let inner = self.inner.clone(); 3709 3709 + let fut = async move { 3710 3710 + let method = FlushAndReloadTracksSvc(inner); 3711 3711 + let codec = tonic::codec::ProstCodec::default(); 3712 3712 + let mut grpc = tonic::server::Grpc::new(codec) 3713 3713 + .apply_compression_config( 3714 3714 + accept_compression_encodings, 3715 3715 + send_compression_encodings, 3716 3716 + ) 3717 3717 + .apply_max_message_size_config( 3718 3718 + max_decoding_message_size, 3719 3719 + max_encoding_message_size, 3720 3720 + ); 3721 3721 + let res = grpc.unary(method, req).await; 3722 3722 + Ok(res) 3723 3723 + }; 3724 3724 + Box::pin(fut) 3725 3725 + } 3726 3726 + "/rockbox.v1alpha1.PlaybackService/GetFilePosition" => { 3727 3727 + #[allow(non_camel_case_types)] 3728 3728 + struct GetFilePositionSvc<T: PlaybackService>(pub Arc<T>); 3729 3729 + impl< 3730 3730 + T: PlaybackService, 3731 3731 + > tonic::server::UnaryService<super::GetFilePositionRequest> 3732 3732 + for GetFilePositionSvc<T> { 3733 3733 + type Response = super::GetFilePositionResponse; 3734 3734 + type Future = BoxFuture< 3735 3735 + tonic::Response<Self::Response>, 3736 3736 + tonic::Status, 3737 3737 + >; 3738 3738 + fn call( 3739 3739 + &mut self, 3740 3740 + request: tonic::Request<super::GetFilePositionRequest>, 3741 3741 + ) -> Self::Future { 3742 3742 + let inner = Arc::clone(&self.0); 3743 3743 + let fut = async move { 3744 3744 + <T as PlaybackService>::get_file_position(&inner, request) 3745 3745 + .await 3746 3746 + }; 3747 3747 + Box::pin(fut) 3748 3748 + } 3749 3749 + } 3750 3750 + let accept_compression_encodings = self.accept_compression_encodings; 3751 3751 + let send_compression_encodings = self.send_compression_encodings; 3752 3752 + let max_decoding_message_size = self.max_decoding_message_size; 3753 3753 + let max_encoding_message_size = self.max_encoding_message_size; 3754 3754 + let inner = self.inner.clone(); 3755 3755 + let fut = async move { 3756 3756 + let method = GetFilePositionSvc(inner); 3757 3757 + let codec = tonic::codec::ProstCodec::default(); 3758 3758 + let mut grpc = tonic::server::Grpc::new(codec) 3759 3759 + .apply_compression_config( 3760 3760 + accept_compression_encodings, 3761 3761 + send_compression_encodings, 3762 3762 + ) 3763 3763 + .apply_max_message_size_config( 3764 3764 + max_decoding_message_size, 3765 3765 + max_encoding_message_size, 3766 3766 + ); 3767 3767 + let res = grpc.unary(method, req).await; 3768 3768 + Ok(res) 3769 3769 + }; 3770 3770 + Box::pin(fut) 3771 3771 + } 3772 3772 + "/rockbox.v1alpha1.PlaybackService/HardStop" => { 3773 3773 + #[allow(non_camel_case_types)] 3774 3774 + struct HardStopSvc<T: PlaybackService>(pub Arc<T>); 3775 3775 + impl< 3776 3776 + T: PlaybackService, 3777 3777 + > tonic::server::UnaryService<super::HardStopRequest> 3778 3778 + for HardStopSvc<T> { 3779 3779 + type Response = super::HardStopResponse; 3780 3780 + type Future = BoxFuture< 3781 3781 + tonic::Response<Self::Response>, 3782 3782 + tonic::Status, 3783 3783 + >; 3784 3784 + fn call( 3785 3785 + &mut self, 3786 3786 + request: tonic::Request<super::HardStopRequest>, 3787 3787 + ) -> Self::Future { 3788 3788 + let inner = Arc::clone(&self.0); 3789 3789 + let fut = async move { 3790 3790 + <T as PlaybackService>::hard_stop(&inner, request).await 3791 3791 + }; 3792 3792 + Box::pin(fut) 3793 3793 + } 3794 3794 + } 3795 3795 + let accept_compression_encodings = self.accept_compression_encodings; 3796 3796 + let send_compression_encodings = self.send_compression_encodings; 3797 3797 + let max_decoding_message_size = self.max_decoding_message_size; 3798 3798 + let max_encoding_message_size = self.max_encoding_message_size; 3799 3799 + let inner = self.inner.clone(); 3800 3800 + let fut = async move { 3801 3801 + let method = HardStopSvc(inner); 3802 3802 + let codec = tonic::codec::ProstCodec::default(); 3803 3803 + let mut grpc = tonic::server::Grpc::new(codec) 3804 3804 + .apply_compression_config( 3805 3805 + accept_compression_encodings, 3806 3806 + send_compression_encodings, 3807 3807 + ) 3808 3808 + .apply_max_message_size_config( 3809 3809 + max_decoding_message_size, 3810 3810 + max_encoding_message_size, 3811 3811 + ); 3812 3812 + let res = grpc.unary(method, req).await; 3813 3813 + Ok(res) 3814 3814 + }; 3815 3815 + Box::pin(fut) 3816 3816 + } 3817 3817 + "/rockbox.v1alpha1.PlaybackService/PlayAlbum" => { 3818 3818 + #[allow(non_camel_case_types)] 3819 3819 + struct PlayAlbumSvc<T: PlaybackService>(pub Arc<T>); 3820 3820 + impl< 3821 3821 + T: PlaybackService, 3822 3822 + > tonic::server::UnaryService<super::PlayAlbumRequest> 3823 3823 + for PlayAlbumSvc<T> { 3824 3824 + type Response = super::PlayAlbumResponse; 3825 3825 + type Future = BoxFuture< 3826 3826 + tonic::Response<Self::Response>, 3827 3827 + tonic::Status, 3828 3828 + >; 3829 3829 + fn call( 3830 3830 + &mut self, 3831 3831 + request: tonic::Request<super::PlayAlbumRequest>, 3832 3832 + ) -> Self::Future { 3833 3833 + let inner = Arc::clone(&self.0); 3834 3834 + let fut = async move { 3835 3835 + <T as PlaybackService>::play_album(&inner, request).await 3836 3836 + }; 3837 3837 + Box::pin(fut) 3838 3838 + } 3839 3839 + } 3840 3840 + let accept_compression_encodings = self.accept_compression_encodings; 3841 3841 + let send_compression_encodings = self.send_compression_encodings; 3842 3842 + let max_decoding_message_size = self.max_decoding_message_size; 3843 3843 + let max_encoding_message_size = self.max_encoding_message_size; 3844 3844 + let inner = self.inner.clone(); 3845 3845 + let fut = async move { 3846 3846 + let method = PlayAlbumSvc(inner); 3847 3847 + let codec = tonic::codec::ProstCodec::default(); 3848 3848 + let mut grpc = tonic::server::Grpc::new(codec) 3849 3849 + .apply_compression_config( 3850 3850 + accept_compression_encodings, 3851 3851 + send_compression_encodings, 3852 3852 + ) 3853 3853 + .apply_max_message_size_config( 3854 3854 + max_decoding_message_size, 3855 3855 + max_encoding_message_size, 3856 3856 + ); 3857 3857 + let res = grpc.unary(method, req).await; 3858 3858 + Ok(res) 3859 3859 + }; 3860 3860 + Box::pin(fut) 3861 3861 + } 3862 3862 + "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks" => { 3863 3863 + #[allow(non_camel_case_types)] 3864 3864 + struct PlayArtistTracksSvc<T: PlaybackService>(pub Arc<T>); 3865 3865 + impl< 3866 3866 + T: PlaybackService, 3867 3867 + > tonic::server::UnaryService<super::PlayArtistTracksRequest> 3868 3868 + for PlayArtistTracksSvc<T> { 3869 3869 + type Response = super::PlayArtistTracksResponse; 3870 3870 + type Future = BoxFuture< 3871 3871 + tonic::Response<Self::Response>, 3872 3872 + tonic::Status, 3873 3873 + >; 3874 3874 + fn call( 3875 3875 + &mut self, 3876 3876 + request: tonic::Request<super::PlayArtistTracksRequest>, 3877 3877 + ) -> Self::Future { 3878 3878 + let inner = Arc::clone(&self.0); 3879 3879 + let fut = async move { 3880 3880 + <T as PlaybackService>::play_artist_tracks(&inner, request) 3881 3881 + .await 3882 3882 + }; 3883 3883 + Box::pin(fut) 3884 3884 + } 3885 3885 + } 3886 3886 + let accept_compression_encodings = self.accept_compression_encodings; 3887 3887 + let send_compression_encodings = self.send_compression_encodings; 3888 3888 + let max_decoding_message_size = self.max_decoding_message_size; 3889 3889 + let max_encoding_message_size = self.max_encoding_message_size; 3890 3890 + let inner = self.inner.clone(); 3891 3891 + let fut = async move { 3892 3892 + let method = PlayArtistTracksSvc(inner); 3893 3893 + let codec = tonic::codec::ProstCodec::default(); 3894 3894 + let mut grpc = tonic::server::Grpc::new(codec) 3895 3895 + .apply_compression_config( 3896 3896 + accept_compression_encodings, 3897 3897 + send_compression_encodings, 3898 3898 + ) 3899 3899 + .apply_max_message_size_config( 3900 3900 + max_decoding_message_size, 3901 3901 + max_encoding_message_size, 3902 3902 + ); 3903 3903 + let res = grpc.unary(method, req).await; 3904 3904 + Ok(res) 3905 3905 + }; 3906 3906 + Box::pin(fut) 3907 3907 + } 3908 3908 + "/rockbox.v1alpha1.PlaybackService/PlayPlaylist" => { 3909 3909 + #[allow(non_camel_case_types)] 3910 3910 + struct PlayPlaylistSvc<T: PlaybackService>(pub Arc<T>); 3911 3911 + impl< 3912 3912 + T: PlaybackService, 3913 3913 + > tonic::server::UnaryService<super::PlayPlaylistRequest> 3914 3914 + for PlayPlaylistSvc<T> { 3915 3915 + type Response = super::PlayPlaylistResponse; 3916 3916 + type Future = BoxFuture< 3917 3917 + tonic::Response<Self::Response>, 3918 3918 + tonic::Status, 3919 3919 + >; 3920 3920 + fn call( 3921 3921 + &mut self, 3922 3922 + request: tonic::Request<super::PlayPlaylistRequest>, 3923 3923 + ) -> Self::Future { 3924 3924 + let inner = Arc::clone(&self.0); 3925 3925 + let fut = async move { 3926 3926 + <T as PlaybackService>::play_playlist(&inner, request).await 3927 3927 + }; 3928 3928 + Box::pin(fut) 3929 3929 + } 3930 3930 + } 3931 3931 + let accept_compression_encodings = self.accept_compression_encodings; 3932 3932 + let send_compression_encodings = self.send_compression_encodings; 3933 3933 + let max_decoding_message_size = self.max_decoding_message_size; 3934 3934 + let max_encoding_message_size = self.max_encoding_message_size; 3935 3935 + let inner = self.inner.clone(); 3936 3936 + let fut = async move { 3937 3937 + let method = PlayPlaylistSvc(inner); 3938 3938 + let codec = tonic::codec::ProstCodec::default(); 3939 3939 + let mut grpc = tonic::server::Grpc::new(codec) 3940 3940 + .apply_compression_config( 3941 3941 + accept_compression_encodings, 3942 3942 + send_compression_encodings, 3943 3943 + ) 3944 3944 + .apply_max_message_size_config( 3945 3945 + max_decoding_message_size, 3946 3946 + max_encoding_message_size, 3947 3947 + ); 3948 3948 + let res = grpc.unary(method, req).await; 3949 3949 + Ok(res) 3950 3950 + }; 3951 3951 + Box::pin(fut) 3952 3952 + } 3953 3953 + "/rockbox.v1alpha1.PlaybackService/PlayDirectory" => { 3954 3954 + #[allow(non_camel_case_types)] 3955 3955 + struct PlayDirectorySvc<T: PlaybackService>(pub Arc<T>); 3956 3956 + impl< 3957 3957 + T: PlaybackService, 3958 3958 + > tonic::server::UnaryService<super::PlayDirectoryRequest> 3959 3959 + for PlayDirectorySvc<T> { 3960 3960 + type Response = super::PlayDirectoryResponse; 3961 3961 + type Future = BoxFuture< 3962 3962 + tonic::Response<Self::Response>, 3963 3963 + tonic::Status, 3964 3964 + >; 3965 3965 + fn call( 3966 3966 + &mut self, 3967 3967 + request: tonic::Request<super::PlayDirectoryRequest>, 3968 3968 + ) -> Self::Future { 3969 3969 + let inner = Arc::clone(&self.0); 3970 3970 + let fut = async move { 3971 3971 + <T as PlaybackService>::play_directory(&inner, request) 3972 3972 + .await 3973 3973 + }; 3974 3974 + Box::pin(fut) 3975 3975 + } 3976 3976 + } 3977 3977 + let accept_compression_encodings = self.accept_compression_encodings; 3978 3978 + let send_compression_encodings = self.send_compression_encodings; 3979 3979 + let max_decoding_message_size = self.max_decoding_message_size; 3980 3980 + let max_encoding_message_size = self.max_encoding_message_size; 3981 3981 + let inner = self.inner.clone(); 3982 3982 + let fut = async move { 3983 3983 + let method = PlayDirectorySvc(inner); 3984 3984 + let codec = tonic::codec::ProstCodec::default(); 3985 3985 + let mut grpc = tonic::server::Grpc::new(codec) 3986 3986 + .apply_compression_config( 3987 3987 + accept_compression_encodings, 3988 3988 + send_compression_encodings, 3989 3989 + ) 3990 3990 + .apply_max_message_size_config( 3991 3991 + max_decoding_message_size, 3992 3992 + max_encoding_message_size, 3993 3993 + ); 3994 3994 + let res = grpc.unary(method, req).await; 3995 3995 + Ok(res) 3996 3996 + }; 3997 3997 + Box::pin(fut) 3998 3998 + } 3999 3999 + "/rockbox.v1alpha1.PlaybackService/PlayTrack" => { 4000 4000 + #[allow(non_camel_case_types)] 4001 4001 + struct PlayTrackSvc<T: PlaybackService>(pub Arc<T>); 4002 4002 + impl< 4003 4003 + T: PlaybackService, 4004 4004 + > tonic::server::UnaryService<super::PlayTrackRequest> 4005 4005 + for PlayTrackSvc<T> { 4006 4006 + type Response = super::PlayTrackResponse; 4007 4007 + type Future = BoxFuture< 4008 4008 + tonic::Response<Self::Response>, 4009 4009 + tonic::Status, 4010 4010 + >; 4011 4011 + fn call( 4012 4012 + &mut self, 4013 4013 + request: tonic::Request<super::PlayTrackRequest>, 4014 4014 + ) -> Self::Future { 4015 4015 + let inner = Arc::clone(&self.0); 4016 4016 + let fut = async move { 4017 4017 + <T as PlaybackService>::play_track(&inner, request).await 4018 4018 + }; 4019 4019 + Box::pin(fut) 4020 4020 + } 4021 4021 + } 4022 4022 + let accept_compression_encodings = self.accept_compression_encodings; 4023 4023 + let send_compression_encodings = self.send_compression_encodings; 4024 4024 + let max_decoding_message_size = self.max_decoding_message_size; 4025 4025 + let max_encoding_message_size = self.max_encoding_message_size; 4026 4026 + let inner = self.inner.clone(); 4027 4027 + let fut = async move { 4028 4028 + let method = PlayTrackSvc(inner); 4029 4029 + let codec = tonic::codec::ProstCodec::default(); 4030 4030 + let mut grpc = tonic::server::Grpc::new(codec) 4031 4031 + .apply_compression_config( 4032 4032 + accept_compression_encodings, 4033 4033 + send_compression_encodings, 4034 4034 + ) 4035 4035 + .apply_max_message_size_config( 4036 4036 + max_decoding_message_size, 4037 4037 + max_encoding_message_size, 4038 4038 + ); 4039 4039 + let res = grpc.unary(method, req).await; 4040 4040 + Ok(res) 4041 4041 + }; 4042 4042 + Box::pin(fut) 4043 4043 + } 4044 4044 + "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks" => { 4045 4045 + #[allow(non_camel_case_types)] 4046 4046 + struct PlayLikedTracksSvc<T: PlaybackService>(pub Arc<T>); 4047 4047 + impl< 4048 4048 + T: PlaybackService, 4049 4049 + > tonic::server::UnaryService<super::PlayLikedTracksRequest> 4050 4050 + for PlayLikedTracksSvc<T> { 4051 4051 + type Response = super::PlayLikedTracksResponse; 4052 4052 + type Future = BoxFuture< 4053 4053 + tonic::Response<Self::Response>, 4054 4054 + tonic::Status, 4055 4055 + >; 4056 4056 + fn call( 4057 4057 + &mut self, 4058 4058 + request: tonic::Request<super::PlayLikedTracksRequest>, 4059 4059 + ) -> Self::Future { 4060 4060 + let inner = Arc::clone(&self.0); 4061 4061 + let fut = async move { 4062 4062 + <T as PlaybackService>::play_liked_tracks(&inner, request) 4063 4063 + .await 4064 4064 + }; 4065 4065 + Box::pin(fut) 4066 4066 + } 4067 4067 + } 4068 4068 + let accept_compression_encodings = self.accept_compression_encodings; 4069 4069 + let send_compression_encodings = self.send_compression_encodings; 4070 4070 + let max_decoding_message_size = self.max_decoding_message_size; 4071 4071 + let max_encoding_message_size = self.max_encoding_message_size; 4072 4072 + let inner = self.inner.clone(); 4073 4073 + let fut = async move { 4074 4074 + let method = PlayLikedTracksSvc(inner); 4075 4075 + let codec = tonic::codec::ProstCodec::default(); 4076 4076 + let mut grpc = tonic::server::Grpc::new(codec) 4077 4077 + .apply_compression_config( 4078 4078 + accept_compression_encodings, 4079 4079 + send_compression_encodings, 4080 4080 + ) 4081 4081 + .apply_max_message_size_config( 4082 4082 + max_decoding_message_size, 4083 4083 + max_encoding_message_size, 4084 4084 + ); 4085 4085 + let res = grpc.unary(method, req).await; 4086 4086 + Ok(res) 4087 4087 + }; 4088 4088 + Box::pin(fut) 4089 4089 + } 4090 4090 + "/rockbox.v1alpha1.PlaybackService/PlayAllTracks" => { 4091 4091 + #[allow(non_camel_case_types)] 4092 4092 + struct PlayAllTracksSvc<T: PlaybackService>(pub Arc<T>); 4093 4093 + impl< 4094 4094 + T: PlaybackService, 4095 4095 + > tonic::server::UnaryService<super::PlayAllTracksRequest> 4096 4096 + for PlayAllTracksSvc<T> { 4097 4097 + type Response = super::PlayAllTracksResponse; 4098 4098 + type Future = BoxFuture< 4099 4099 + tonic::Response<Self::Response>, 4100 4100 + tonic::Status, 4101 4101 + >; 4102 4102 + fn call( 4103 4103 + &mut self, 4104 4104 + request: tonic::Request<super::PlayAllTracksRequest>, 4105 4105 + ) -> Self::Future { 4106 4106 + let inner = Arc::clone(&self.0); 4107 4107 + let fut = async move { 4108 4108 + <T as PlaybackService>::play_all_tracks(&inner, request) 4109 4109 + .await 4110 4110 + }; 4111 4111 + Box::pin(fut) 4112 4112 + } 4113 4113 + } 4114 4114 + let accept_compression_encodings = self.accept_compression_encodings; 4115 4115 + let send_compression_encodings = self.send_compression_encodings; 4116 4116 + let max_decoding_message_size = self.max_decoding_message_size; 4117 4117 + let max_encoding_message_size = self.max_encoding_message_size; 4118 4118 + let inner = self.inner.clone(); 4119 4119 + let fut = async move { 4120 4120 + let method = PlayAllTracksSvc(inner); 4121 4121 + let codec = tonic::codec::ProstCodec::default(); 4122 4122 + let mut grpc = tonic::server::Grpc::new(codec) 4123 4123 + .apply_compression_config( 4124 4124 + accept_compression_encodings, 4125 4125 + send_compression_encodings, 4126 4126 + ) 4127 4127 + .apply_max_message_size_config( 4128 4128 + max_decoding_message_size, 4129 4129 + max_encoding_message_size, 4130 4130 + ); 4131 4131 + let res = grpc.unary(method, req).await; 4132 4132 + Ok(res) 4133 4133 + }; 4134 4134 + Box::pin(fut) 4135 4135 + } 4136 4136 + "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack" => { 4137 4137 + #[allow(non_camel_case_types)] 4138 4138 + struct StreamCurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 4139 4139 + impl< 4140 4140 + T: PlaybackService, 4141 4141 + > tonic::server::ServerStreamingService< 4142 4142 + super::StreamCurrentTrackRequest, 4143 4143 + > for StreamCurrentTrackSvc<T> { 4144 4144 + type Response = super::CurrentTrackResponse; 4145 4145 + type ResponseStream = T::StreamCurrentTrackStream; 4146 4146 + type Future = BoxFuture< 4147 4147 + tonic::Response<Self::ResponseStream>, 4148 4148 + tonic::Status, 4149 4149 + >; 4150 4150 + fn call( 4151 4151 + &mut self, 4152 4152 + request: tonic::Request<super::StreamCurrentTrackRequest>, 4153 4153 + ) -> Self::Future { 4154 4154 + let inner = Arc::clone(&self.0); 4155 4155 + let fut = async move { 4156 4156 + <T as PlaybackService>::stream_current_track( 4157 4157 + &inner, 4158 4158 + request, 4159 4159 + ) 4160 4160 + .await 4161 4161 + }; 4162 4162 + Box::pin(fut) 4163 4163 + } 4164 4164 + } 4165 4165 + let accept_compression_encodings = self.accept_compression_encodings; 4166 4166 + let send_compression_encodings = self.send_compression_encodings; 4167 4167 + let max_decoding_message_size = self.max_decoding_message_size; 4168 4168 + let max_encoding_message_size = self.max_encoding_message_size; 4169 4169 + let inner = self.inner.clone(); 4170 4170 + let fut = async move { 4171 4171 + let method = StreamCurrentTrackSvc(inner); 4172 4172 + let codec = tonic::codec::ProstCodec::default(); 4173 4173 + let mut grpc = tonic::server::Grpc::new(codec) 4174 4174 + .apply_compression_config( 4175 4175 + accept_compression_encodings, 4176 4176 + send_compression_encodings, 4177 4177 + ) 4178 4178 + .apply_max_message_size_config( 4179 4179 + max_decoding_message_size, 4180 4180 + max_encoding_message_size, 4181 4181 + ); 4182 4182 + let res = grpc.server_streaming(method, req).await; 4183 4183 + Ok(res) 4184 4184 + }; 4185 4185 + Box::pin(fut) 4186 4186 + } 4187 4187 + "/rockbox.v1alpha1.PlaybackService/StreamStatus" => { 4188 4188 + #[allow(non_camel_case_types)] 4189 4189 + struct StreamStatusSvc<T: PlaybackService>(pub Arc<T>); 4190 4190 + impl< 4191 4191 + T: PlaybackService, 4192 4192 + > tonic::server::ServerStreamingService<super::StreamStatusRequest> 4193 4193 + for StreamStatusSvc<T> { 4194 4194 + type Response = super::StatusResponse; 4195 4195 + type ResponseStream = T::StreamStatusStream; 4196 4196 + type Future = BoxFuture< 4197 4197 + tonic::Response<Self::ResponseStream>, 4198 4198 + tonic::Status, 4199 4199 + >; 4200 4200 + fn call( 4201 4201 + &mut self, 4202 4202 + request: tonic::Request<super::StreamStatusRequest>, 4203 4203 + ) -> Self::Future { 4204 4204 + let inner = Arc::clone(&self.0); 4205 4205 + let fut = async move { 4206 4206 + <T as PlaybackService>::stream_status(&inner, request).await 4207 4207 + }; 4208 4208 + Box::pin(fut) 4209 4209 + } 4210 4210 + } 4211 4211 + let accept_compression_encodings = self.accept_compression_encodings; 4212 4212 + let send_compression_encodings = self.send_compression_encodings; 4213 4213 + let max_decoding_message_size = self.max_decoding_message_size; 4214 4214 + let max_encoding_message_size = self.max_encoding_message_size; 4215 4215 + let inner = self.inner.clone(); 4216 4216 + let fut = async move { 4217 4217 + let method = StreamStatusSvc(inner); 4218 4218 + let codec = tonic::codec::ProstCodec::default(); 4219 4219 + let mut grpc = tonic::server::Grpc::new(codec) 4220 4220 + .apply_compression_config( 4221 4221 + accept_compression_encodings, 4222 4222 + send_compression_encodings, 4223 4223 + ) 4224 4224 + .apply_max_message_size_config( 4225 4225 + max_decoding_message_size, 4226 4226 + max_encoding_message_size, 4227 4227 + ); 4228 4228 + let res = grpc.server_streaming(method, req).await; 4229 4229 + Ok(res) 4230 4230 + }; 4231 4231 + Box::pin(fut) 4232 4232 + } 4233 4233 + "/rockbox.v1alpha1.PlaybackService/StreamPlaylist" => { 4234 4234 + #[allow(non_camel_case_types)] 4235 4235 + struct StreamPlaylistSvc<T: PlaybackService>(pub Arc<T>); 4236 4236 + impl< 4237 4237 + T: PlaybackService, 4238 4238 + > tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 4239 4239 + for StreamPlaylistSvc<T> { 4240 4240 + type Response = super::PlaylistResponse; 4241 4241 + type ResponseStream = T::StreamPlaylistStream; 4242 4242 + type Future = BoxFuture< 4243 4243 + tonic::Response<Self::ResponseStream>, 4244 4244 + tonic::Status, 4245 4245 + >; 4246 4246 + fn call( 4247 4247 + &mut self, 4248 4248 + request: tonic::Request<super::StreamPlaylistRequest>, 4249 4249 + ) -> Self::Future { 4250 4250 + let inner = Arc::clone(&self.0); 4251 4251 + let fut = async move { 4252 4252 + <T as PlaybackService>::stream_playlist(&inner, request) 4253 4253 + .await 4254 4254 + }; 4255 4255 + Box::pin(fut) 4256 4256 + } 4257 4257 + } 4258 4258 + let accept_compression_encodings = self.accept_compression_encodings; 4259 4259 + let send_compression_encodings = self.send_compression_encodings; 4260 4260 + let max_decoding_message_size = self.max_decoding_message_size; 4261 4261 + let max_encoding_message_size = self.max_encoding_message_size; 4262 4262 + let inner = self.inner.clone(); 4263 4263 + let fut = async move { 4264 4264 + let method = StreamPlaylistSvc(inner); 4265 4265 + let codec = tonic::codec::ProstCodec::default(); 4266 4266 + let mut grpc = tonic::server::Grpc::new(codec) 4267 4267 + .apply_compression_config( 4268 4268 + accept_compression_encodings, 4269 4269 + send_compression_encodings, 4270 4270 + ) 4271 4271 + .apply_max_message_size_config( 4272 4272 + max_decoding_message_size, 4273 4273 + max_encoding_message_size, 4274 4274 + ); 4275 4275 + let res = grpc.server_streaming(method, req).await; 4276 4276 + Ok(res) 4277 4277 + }; 4278 4278 + Box::pin(fut) 4279 4279 + } 4280 4280 + _ => { 4281 4281 + Box::pin(async move { 4282 4282 + let mut response = http::Response::new(empty_body()); 4283 4283 + let headers = response.headers_mut(); 4284 4284 + headers 4285 4285 + .insert( 4286 4286 + tonic::Status::GRPC_STATUS, 4287 4287 + (tonic::Code::Unimplemented as i32).into(), 4288 4288 + ); 4289 4289 + headers 4290 4290 + .insert( 4291 4291 + http::header::CONTENT_TYPE, 4292 4292 + tonic::metadata::GRPC_CONTENT_TYPE, 4293 4293 + ); 4294 4294 + Ok(response) 4295 4295 + }) 4296 4296 + } 4297 4297 + } 4298 4298 + } 4299 4299 + } 4300 4300 + impl<T> Clone for PlaybackServiceServer<T> { 4301 4301 + fn clone(&self) -> Self { 4302 4302 + let inner = self.inner.clone(); 4303 4303 + Self { 4304 4304 + inner, 4305 4305 + accept_compression_encodings: self.accept_compression_encodings, 4306 4306 + send_compression_encodings: self.send_compression_encodings, 4307 4307 + max_decoding_message_size: self.max_decoding_message_size, 4308 4308 + max_encoding_message_size: self.max_encoding_message_size, 4309 4309 + } 4310 4310 + } 4311 4311 + } 4312 4312 + /// Generated gRPC service name 4313 4313 + pub const SERVICE_NAME: &str = "rockbox.v1alpha1.PlaybackService"; 4314 4314 + impl<T> tonic::server::NamedService for PlaybackServiceServer<T> { 4315 4315 + const NAME: &'static str = SERVICE_NAME; 4316 4316 + } 4317 4317 + } 4318 4318 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4319 4319 + pub struct GetCurrentRequest {} 4320 4320 + #[derive(Clone, PartialEq, ::prost::Message)] 4321 4321 + pub struct GetCurrentResponse { 4322 4322 + #[prost(int32, tag = "1")] 4323 4323 + pub index: i32, 4324 4324 + #[prost(int32, tag = "2")] 4325 4325 + pub amount: i32, 4326 4326 + #[prost(int32, tag = "3")] 4327 4327 + pub max_playlist_size: i32, 4328 4328 + #[prost(int32, tag = "4")] 4329 4329 + pub first_index: i32, 4330 4330 + #[prost(int32, tag = "5")] 4331 4331 + pub last_insert_pos: i32, 4332 4332 + #[prost(int32, tag = "6")] 4333 4333 + pub seed: i32, 4334 4334 + #[prost(int32, tag = "7")] 4335 4335 + pub last_shuffled_start: i32, 4336 4336 + #[prost(message, repeated, tag = "8")] 4337 4337 + pub tracks: ::prost::alloc::vec::Vec<CurrentTrackResponse>, 4338 4338 + } 4339 4339 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4340 4340 + pub struct GetResumeInfoRequest {} 4341 4341 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4342 4342 + pub struct GetResumeInfoResponse {} 4343 4343 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4344 4344 + pub struct GetTrackInfoRequest {} 4345 4345 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4346 4346 + pub struct GetTrackInfoResponse {} 4347 4347 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4348 4348 + pub struct GetFirstIndexRequest {} 4349 4349 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4350 4350 + pub struct GetFirstIndexResponse {} 4351 4351 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4352 4352 + pub struct GetDisplayIndexRequest {} 4353 4353 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4354 4354 + pub struct GetDisplayIndexResponse {} 4355 4355 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4356 4356 + pub struct AmountRequest {} 4357 4357 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4358 4358 + pub struct AmountResponse { 4359 4359 + #[prost(int32, tag = "1")] 4360 4360 + pub amount: i32, 4361 4361 + } 4362 4362 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4363 4363 + pub struct PlaylistResumeRequest {} 4364 4364 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4365 4365 + pub struct PlaylistResumeResponse { 4366 4366 + #[prost(int32, tag = "1")] 4367 4367 + pub code: i32, 4368 4368 + } 4369 4369 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4370 4370 + pub struct ResumeTrackRequest { 4371 4371 + #[prost(int32, tag = "1")] 4372 4372 + pub start_index: i32, 4373 4373 + #[prost(uint32, tag = "2")] 4374 4374 + pub crc: u32, 4375 4375 + #[prost(uint64, tag = "3")] 4376 4376 + pub elapsed: u64, 4377 4377 + #[prost(uint64, tag = "4")] 4378 4378 + pub offset: u64, 4379 4379 + } 4380 4380 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4381 4381 + pub struct ResumeTrackResponse {} 4382 4382 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4383 4383 + pub struct SetModifiedRequest {} 4384 4384 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4385 4385 + pub struct SetModifiedResponse {} 4386 4386 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4387 4387 + pub struct StartRequest { 4388 4388 + #[prost(int32, optional, tag = "1")] 4389 4389 + pub start_index: ::core::option::Option<i32>, 4390 4390 + #[prost(int32, optional, tag = "2")] 4391 4391 + pub elapsed: ::core::option::Option<i32>, 4392 4392 + #[prost(int32, optional, tag = "3")] 4393 4393 + pub offset: ::core::option::Option<i32>, 4394 4394 + } 4395 4395 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4396 4396 + pub struct StartResponse {} 4397 4397 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4398 4398 + pub struct SyncRequest {} 4399 4399 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4400 4400 + pub struct SyncResponse {} 4401 4401 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4402 4402 + pub struct RemoveAllTracksRequest {} 4403 4403 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4404 4404 + pub struct RemoveAllTracksResponse {} 4405 4405 + #[derive(Clone, PartialEq, ::prost::Message)] 4406 4406 + pub struct RemoveTracksRequest { 4407 4407 + #[prost(int32, repeated, tag = "1")] 4408 4408 + pub positions: ::prost::alloc::vec::Vec<i32>, 4409 4409 + } 4410 4410 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4411 4411 + pub struct RemoveTracksResponse {} 4412 4412 + #[derive(Clone, PartialEq, ::prost::Message)] 4413 4413 + pub struct CreatePlaylistRequest { 4414 4414 + #[prost(string, tag = "1")] 4415 4415 + pub name: ::prost::alloc::string::String, 4416 4416 + #[prost(string, repeated, tag = "2")] 4417 4417 + pub tracks: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, 4418 4418 + #[prost(string, optional, tag = "3")] 4419 4419 + pub folder_id: ::core::option::Option<::prost::alloc::string::String>, 4420 4420 + } 4421 4421 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4422 4422 + pub struct CreatePlaylistResponse { 4423 4423 + #[prost(int32, tag = "1")] 4424 4424 + pub start_index: i32, 4425 4425 + } 4426 4426 + #[derive(Clone, PartialEq, ::prost::Message)] 4427 4427 + pub struct InsertTracksRequest { 4428 4428 + #[prost(string, optional, tag = "1")] 4429 4429 + pub playlist_id: ::core::option::Option<::prost::alloc::string::String>, 4430 4430 + #[prost(int32, tag = "2")] 4431 4431 + pub position: i32, 4432 4432 + #[prost(string, repeated, tag = "3")] 4433 4433 + pub tracks: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, 4434 4434 + #[prost(bool, optional, tag = "4")] 4435 4435 + pub shuffle: ::core::option::Option<bool>, 4436 4436 + } 4437 4437 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4438 4438 + pub struct InsertTracksResponse {} 4439 4439 + #[derive(Clone, PartialEq, ::prost::Message)] 4440 4440 + pub struct InsertDirectoryRequest { 4441 4441 + #[prost(string, optional, tag = "1")] 4442 4442 + pub playlist_id: ::core::option::Option<::prost::alloc::string::String>, 4443 4443 + #[prost(int32, tag = "2")] 4444 4444 + pub position: i32, 4445 4445 + #[prost(string, tag = "3")] 4446 4446 + pub directory: ::prost::alloc::string::String, 4447 4447 + #[prost(bool, optional, tag = "4")] 4448 4448 + pub recurse: ::core::option::Option<bool>, 4449 4449 + #[prost(bool, optional, tag = "5")] 4450 4450 + pub shuffle: ::core::option::Option<bool>, 4451 4451 + } 4452 4452 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4453 4453 + pub struct InsertDirectoryResponse {} 4454 4454 + #[derive(Clone, PartialEq, ::prost::Message)] 4455 4455 + pub struct InsertPlaylistRequest { 4456 4456 + #[prost(int32, tag = "1")] 4457 4457 + pub position: i32, 4458 4458 + #[prost(string, tag = "2")] 4459 4459 + pub target_playlist_id: ::prost::alloc::string::String, 4460 4460 + #[prost(string, tag = "3")] 4461 4461 + pub playlist_id: ::prost::alloc::string::String, 4462 4462 + #[prost(bool, optional, tag = "4")] 4463 4463 + pub shuffle: ::core::option::Option<bool>, 4464 4464 + } 4465 4465 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4466 4466 + pub struct InsertPlaylistResponse {} 4467 4467 + #[derive(Clone, PartialEq, ::prost::Message)] 4468 4468 + pub struct InsertAlbumRequest { 4469 4469 + #[prost(int32, tag = "1")] 4470 4470 + pub position: i32, 4471 4471 + #[prost(string, tag = "2")] 4472 4472 + pub album_id: ::prost::alloc::string::String, 4473 4473 + #[prost(bool, optional, tag = "3")] 4474 4474 + pub shuffle: ::core::option::Option<bool>, 4475 4475 + } 4476 4476 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4477 4477 + pub struct InsertAlbumResponse {} 4478 4478 + #[derive(Clone, PartialEq, ::prost::Message)] 4479 4479 + pub struct InsertArtistTracksRequest { 4480 4480 + #[prost(int32, tag = "1")] 4481 4481 + pub position: i32, 4482 4482 + #[prost(string, tag = "2")] 4483 4483 + pub artist_id: ::prost::alloc::string::String, 4484 4484 + #[prost(bool, optional, tag = "3")] 4485 4485 + pub shuffle: ::core::option::Option<bool>, 4486 4486 + } 4487 4487 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4488 4488 + pub struct InsertArtistTracksResponse {} 4489 4489 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4490 4490 + pub struct ShufflePlaylistRequest { 4491 4491 + #[prost(int32, tag = "1")] 4492 4492 + pub start_index: i32, 4493 4493 + } 4494 4494 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 4495 4495 + pub struct ShufflePlaylistResponse {} 4496 4496 + /// Generated client implementations. 4497 4497 + pub mod playlist_service_client { 4498 4498 + #![allow( 4499 4499 + unused_variables, 4500 4500 + dead_code, 4501 4501 + missing_docs, 4502 4502 + clippy::wildcard_imports, 4503 4503 + clippy::let_unit_value, 4504 4504 + )] 4505 4505 + use tonic::codegen::*; 4506 4506 + use tonic::codegen::http::Uri; 4507 4507 + #[derive(Debug, Clone)] 4508 4508 + pub struct PlaylistServiceClient<T> { 4509 4509 + inner: tonic::client::Grpc<T>, 4510 4510 + } 4511 4511 + impl PlaylistServiceClient<tonic::transport::Channel> { 4512 4512 + /// Attempt to create a new client by connecting to a given endpoint. 4513 4513 + pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error> 4514 4514 + where 4515 4515 + D: TryInto<tonic::transport::Endpoint>, 4516 4516 + D::Error: Into<StdError>, 4517 4517 + { 4518 4518 + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; 4519 4519 + Ok(Self::new(conn)) 4520 4520 + } 4521 4521 + } 4522 4522 + impl<T> PlaylistServiceClient<T> 4523 4523 + where 4524 4524 + T: tonic::client::GrpcService<tonic::body::BoxBody>, 4525 4525 + T::Error: Into<StdError>, 4526 4526 + T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static, 4527 4527 + <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send, 4528 4528 + { 4529 4529 + pub fn new(inner: T) -> Self { 4530 4530 + let inner = tonic::client::Grpc::new(inner); 4531 4531 + Self { inner } 4532 4532 + } 4533 4533 + pub fn with_origin(inner: T, origin: Uri) -> Self { 4534 4534 + let inner = tonic::client::Grpc::with_origin(inner, origin); 4535 4535 + Self { inner } 4536 4536 + } 4537 4537 + pub fn with_interceptor<F>( 4538 4538 + inner: T, 4539 4539 + interceptor: F, 4540 4540 + ) -> PlaylistServiceClient<InterceptedService<T, F>> 4541 4541 + where 4542 4542 + F: tonic::service::Interceptor, 4543 4543 + T::ResponseBody: Default, 4544 4544 + T: tonic::codegen::Service< 4545 4545 + http::Request<tonic::body::BoxBody>, 4546 4546 + Response = http::Response< 4547 4547 + <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 4548 4548 + >, 4549 4549 + >, 4550 4550 + <T as tonic::codegen::Service< 4551 4551 + http::Request<tonic::body::BoxBody>, 4552 4552 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 4553 4553 + { 4554 4554 + PlaylistServiceClient::new(InterceptedService::new(inner, interceptor)) 4555 4555 + } 4556 4556 + /// Compress requests with the given encoding. 4557 4557 + /// 4558 4558 + /// This requires the server to support it otherwise it might respond with an 4559 4559 + /// error. 4560 4560 + #[must_use] 4561 4561 + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { 4562 4562 + self.inner = self.inner.send_compressed(encoding); 4563 4563 + self 4564 4564 + } 4565 4565 + /// Enable decompressing responses. 4566 4566 + #[must_use] 4567 4567 + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { 4568 4568 + self.inner = self.inner.accept_compressed(encoding); 4569 4569 + self 4570 4570 + } 4571 4571 + /// Limits the maximum size of a decoded message. 4572 4572 + /// 4573 4573 + /// Default: `4MB` 4574 4574 + #[must_use] 4575 4575 + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { 4576 4576 + self.inner = self.inner.max_decoding_message_size(limit); 4577 4577 + self 4578 4578 + } 4579 4579 + /// Limits the maximum size of an encoded message. 4580 4580 + /// 4581 4581 + /// Default: `usize::MAX` 4582 4582 + #[must_use] 4583 4583 + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { 4584 4584 + self.inner = self.inner.max_encoding_message_size(limit); 4585 4585 + self 4586 4586 + } 4587 4587 + pub async fn get_current( 4588 4588 + &mut self, 4589 4589 + request: impl tonic::IntoRequest<super::GetCurrentRequest>, 4590 4590 + ) -> std::result::Result< 4591 4591 + tonic::Response<super::GetCurrentResponse>, 4592 4592 + tonic::Status, 4593 4593 + > { 4594 4594 + self.inner 4595 4595 + .ready() 4596 4596 + .await 4597 4597 + .map_err(|e| { 4598 4598 + tonic::Status::unknown( 4599 4599 + format!("Service was not ready: {}", e.into()), 4600 4600 + ) 4601 4601 + })?; 4602 4602 + let codec = tonic::codec::ProstCodec::default(); 4603 4603 + let path = http::uri::PathAndQuery::from_static( 4604 4604 + "/rockbox.v1alpha1.PlaylistService/GetCurrent", 4605 4605 + ); 4606 4606 + let mut req = request.into_request(); 4607 4607 + req.extensions_mut() 4608 4608 + .insert( 4609 4609 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetCurrent"), 4610 4610 + ); 4611 4611 + self.inner.unary(req, path, codec).await 4612 4612 + } 4613 4613 + pub async fn get_resume_info( 4614 4614 + &mut self, 4615 4615 + request: impl tonic::IntoRequest<super::GetResumeInfoRequest>, 4616 4616 + ) -> std::result::Result< 4617 4617 + tonic::Response<super::GetResumeInfoResponse>, 4618 4618 + tonic::Status, 4619 4619 + > { 4620 4620 + self.inner 4621 4621 + .ready() 4622 4622 + .await 4623 4623 + .map_err(|e| { 4624 4624 + tonic::Status::unknown( 4625 4625 + format!("Service was not ready: {}", e.into()), 4626 4626 + ) 4627 4627 + })?; 4628 4628 + let codec = tonic::codec::ProstCodec::default(); 4629 4629 + let path = http::uri::PathAndQuery::from_static( 4630 4630 + "/rockbox.v1alpha1.PlaylistService/GetResumeInfo", 4631 4631 + ); 4632 4632 + let mut req = request.into_request(); 4633 4633 + req.extensions_mut() 4634 4634 + .insert( 4635 4635 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetResumeInfo"), 4636 4636 + ); 4637 4637 + self.inner.unary(req, path, codec).await 4638 4638 + } 4639 4639 + pub async fn get_track_info( 4640 4640 + &mut self, 4641 4641 + request: impl tonic::IntoRequest<super::GetTrackInfoRequest>, 4642 4642 + ) -> std::result::Result< 4643 4643 + tonic::Response<super::GetTrackInfoResponse>, 4644 4644 + tonic::Status, 4645 4645 + > { 4646 4646 + self.inner 4647 4647 + .ready() 4648 4648 + .await 4649 4649 + .map_err(|e| { 4650 4650 + tonic::Status::unknown( 4651 4651 + format!("Service was not ready: {}", e.into()), 4652 4652 + ) 4653 4653 + })?; 4654 4654 + let codec = tonic::codec::ProstCodec::default(); 4655 4655 + let path = http::uri::PathAndQuery::from_static( 4656 4656 + "/rockbox.v1alpha1.PlaylistService/GetTrackInfo", 4657 4657 + ); 4658 4658 + let mut req = request.into_request(); 4659 4659 + req.extensions_mut() 4660 4660 + .insert( 4661 4661 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetTrackInfo"), 4662 4662 + ); 4663 4663 + self.inner.unary(req, path, codec).await 4664 4664 + } 4665 4665 + pub async fn get_first_index( 4666 4666 + &mut self, 4667 4667 + request: impl tonic::IntoRequest<super::GetFirstIndexRequest>, 4668 4668 + ) -> std::result::Result< 4669 4669 + tonic::Response<super::GetFirstIndexResponse>, 4670 4670 + tonic::Status, 4671 4671 + > { 4672 4672 + self.inner 4673 4673 + .ready() 4674 4674 + .await 4675 4675 + .map_err(|e| { 4676 4676 + tonic::Status::unknown( 4677 4677 + format!("Service was not ready: {}", e.into()), 4678 4678 + ) 4679 4679 + })?; 4680 4680 + let codec = tonic::codec::ProstCodec::default(); 4681 4681 + let path = http::uri::PathAndQuery::from_static( 4682 4682 + "/rockbox.v1alpha1.PlaylistService/GetFirstIndex", 4683 4683 + ); 4684 4684 + let mut req = request.into_request(); 4685 4685 + req.extensions_mut() 4686 4686 + .insert( 4687 4687 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetFirstIndex"), 4688 4688 + ); 4689 4689 + self.inner.unary(req, path, codec).await 4690 4690 + } 4691 4691 + pub async fn get_display_index( 4692 4692 + &mut self, 4693 4693 + request: impl tonic::IntoRequest<super::GetDisplayIndexRequest>, 4694 4694 + ) -> std::result::Result< 4695 4695 + tonic::Response<super::GetDisplayIndexResponse>, 4696 4696 + tonic::Status, 4697 4697 + > { 4698 4698 + self.inner 4699 4699 + .ready() 4700 4700 + .await 4701 4701 + .map_err(|e| { 4702 4702 + tonic::Status::unknown( 4703 4703 + format!("Service was not ready: {}", e.into()), 4704 4704 + ) 4705 4705 + })?; 4706 4706 + let codec = tonic::codec::ProstCodec::default(); 4707 4707 + let path = http::uri::PathAndQuery::from_static( 4708 4708 + "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex", 4709 4709 + ); 4710 4710 + let mut req = request.into_request(); 4711 4711 + req.extensions_mut() 4712 4712 + .insert( 4713 4713 + GrpcMethod::new( 4714 4714 + "rockbox.v1alpha1.PlaylistService", 4715 4715 + "GetDisplayIndex", 4716 4716 + ), 4717 4717 + ); 4718 4718 + self.inner.unary(req, path, codec).await 4719 4719 + } 4720 4720 + pub async fn amount( 4721 4721 + &mut self, 4722 4722 + request: impl tonic::IntoRequest<super::AmountRequest>, 4723 4723 + ) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status> { 4724 4724 + self.inner 4725 4725 + .ready() 4726 4726 + .await 4727 4727 + .map_err(|e| { 4728 4728 + tonic::Status::unknown( 4729 4729 + format!("Service was not ready: {}", e.into()), 4730 4730 + ) 4731 4731 + })?; 4732 4732 + let codec = tonic::codec::ProstCodec::default(); 4733 4733 + let path = http::uri::PathAndQuery::from_static( 4734 4734 + "/rockbox.v1alpha1.PlaylistService/Amount", 4735 4735 + ); 4736 4736 + let mut req = request.into_request(); 4737 4737 + req.extensions_mut() 4738 4738 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Amount")); 4739 4739 + self.inner.unary(req, path, codec).await 4740 4740 + } 4741 4741 + pub async fn playlist_resume( 4742 4742 + &mut self, 4743 4743 + request: impl tonic::IntoRequest<super::PlaylistResumeRequest>, 4744 4744 + ) -> std::result::Result< 4745 4745 + tonic::Response<super::PlaylistResumeResponse>, 4746 4746 + tonic::Status, 4747 4747 + > { 4748 4748 + self.inner 4749 4749 + .ready() 4750 4750 + .await 4751 4751 + .map_err(|e| { 4752 4752 + tonic::Status::unknown( 4753 4753 + format!("Service was not ready: {}", e.into()), 4754 4754 + ) 4755 4755 + })?; 4756 4756 + let codec = tonic::codec::ProstCodec::default(); 4757 4757 + let path = http::uri::PathAndQuery::from_static( 4758 4758 + "/rockbox.v1alpha1.PlaylistService/PlaylistResume", 4759 4759 + ); 4760 4760 + let mut req = request.into_request(); 4761 4761 + req.extensions_mut() 4762 4762 + .insert( 4763 4763 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "PlaylistResume"), 4764 4764 + ); 4765 4765 + self.inner.unary(req, path, codec).await 4766 4766 + } 4767 4767 + pub async fn resume_track( 4768 4768 + &mut self, 4769 4769 + request: impl tonic::IntoRequest<super::ResumeTrackRequest>, 4770 4770 + ) -> std::result::Result< 4771 4771 + tonic::Response<super::ResumeTrackResponse>, 4772 4772 + tonic::Status, 4773 4773 + > { 4774 4774 + self.inner 4775 4775 + .ready() 4776 4776 + .await 4777 4777 + .map_err(|e| { 4778 4778 + tonic::Status::unknown( 4779 4779 + format!("Service was not ready: {}", e.into()), 4780 4780 + ) 4781 4781 + })?; 4782 4782 + let codec = tonic::codec::ProstCodec::default(); 4783 4783 + let path = http::uri::PathAndQuery::from_static( 4784 4784 + "/rockbox.v1alpha1.PlaylistService/ResumeTrack", 4785 4785 + ); 4786 4786 + let mut req = request.into_request(); 4787 4787 + req.extensions_mut() 4788 4788 + .insert( 4789 4789 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "ResumeTrack"), 4790 4790 + ); 4791 4791 + self.inner.unary(req, path, codec).await 4792 4792 + } 4793 4793 + pub async fn set_modified( 4794 4794 + &mut self, 4795 4795 + request: impl tonic::IntoRequest<super::SetModifiedRequest>, 4796 4796 + ) -> std::result::Result< 4797 4797 + tonic::Response<super::SetModifiedResponse>, 4798 4798 + tonic::Status, 4799 4799 + > { 4800 4800 + self.inner 4801 4801 + .ready() 4802 4802 + .await 4803 4803 + .map_err(|e| { 4804 4804 + tonic::Status::unknown( 4805 4805 + format!("Service was not ready: {}", e.into()), 4806 4806 + ) 4807 4807 + })?; 4808 4808 + let codec = tonic::codec::ProstCodec::default(); 4809 4809 + let path = http::uri::PathAndQuery::from_static( 4810 4810 + "/rockbox.v1alpha1.PlaylistService/SetModified", 4811 4811 + ); 4812 4812 + let mut req = request.into_request(); 4813 4813 + req.extensions_mut() 4814 4814 + .insert( 4815 4815 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "SetModified"), 4816 4816 + ); 4817 4817 + self.inner.unary(req, path, codec).await 4818 4818 + } 4819 4819 + pub async fn start( 4820 4820 + &mut self, 4821 4821 + request: impl tonic::IntoRequest<super::StartRequest>, 4822 4822 + ) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status> { 4823 4823 + self.inner 4824 4824 + .ready() 4825 4825 + .await 4826 4826 + .map_err(|e| { 4827 4827 + tonic::Status::unknown( 4828 4828 + format!("Service was not ready: {}", e.into()), 4829 4829 + ) 4830 4830 + })?; 4831 4831 + let codec = tonic::codec::ProstCodec::default(); 4832 4832 + let path = http::uri::PathAndQuery::from_static( 4833 4833 + "/rockbox.v1alpha1.PlaylistService/Start", 4834 4834 + ); 4835 4835 + let mut req = request.into_request(); 4836 4836 + req.extensions_mut() 4837 4837 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Start")); 4838 4838 + self.inner.unary(req, path, codec).await 4839 4839 + } 4840 4840 + pub async fn sync( 4841 4841 + &mut self, 4842 4842 + request: impl tonic::IntoRequest<super::SyncRequest>, 4843 4843 + ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> { 4844 4844 + self.inner 4845 4845 + .ready() 4846 4846 + .await 4847 4847 + .map_err(|e| { 4848 4848 + tonic::Status::unknown( 4849 4849 + format!("Service was not ready: {}", e.into()), 4850 4850 + ) 4851 4851 + })?; 4852 4852 + let codec = tonic::codec::ProstCodec::default(); 4853 4853 + let path = http::uri::PathAndQuery::from_static( 4854 4854 + "/rockbox.v1alpha1.PlaylistService/Sync", 4855 4855 + ); 4856 4856 + let mut req = request.into_request(); 4857 4857 + req.extensions_mut() 4858 4858 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Sync")); 4859 4859 + self.inner.unary(req, path, codec).await 4860 4860 + } 4861 4861 + pub async fn remove_all_tracks( 4862 4862 + &mut self, 4863 4863 + request: impl tonic::IntoRequest<super::RemoveAllTracksRequest>, 4864 4864 + ) -> std::result::Result< 4865 4865 + tonic::Response<super::RemoveAllTracksResponse>, 4866 4866 + tonic::Status, 4867 4867 + > { 4868 4868 + self.inner 4869 4869 + .ready() 4870 4870 + .await 4871 4871 + .map_err(|e| { 4872 4872 + tonic::Status::unknown( 4873 4873 + format!("Service was not ready: {}", e.into()), 4874 4874 + ) 4875 4875 + })?; 4876 4876 + let codec = tonic::codec::ProstCodec::default(); 4877 4877 + let path = http::uri::PathAndQuery::from_static( 4878 4878 + "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks", 4879 4879 + ); 4880 4880 + let mut req = request.into_request(); 4881 4881 + req.extensions_mut() 4882 4882 + .insert( 4883 4883 + GrpcMethod::new( 4884 4884 + "rockbox.v1alpha1.PlaylistService", 4885 4885 + "RemoveAllTracks", 4886 4886 + ), 4887 4887 + ); 4888 4888 + self.inner.unary(req, path, codec).await 4889 4889 + } 4890 4890 + pub async fn remove_tracks( 4891 4891 + &mut self, 4892 4892 + request: impl tonic::IntoRequest<super::RemoveTracksRequest>, 4893 4893 + ) -> std::result::Result< 4894 4894 + tonic::Response<super::RemoveTracksResponse>, 4895 4895 + tonic::Status, 4896 4896 + > { 4897 4897 + self.inner 4898 4898 + .ready() 4899 4899 + .await 4900 4900 + .map_err(|e| { 4901 4901 + tonic::Status::unknown( 4902 4902 + format!("Service was not ready: {}", e.into()), 4903 4903 + ) 4904 4904 + })?; 4905 4905 + let codec = tonic::codec::ProstCodec::default(); 4906 4906 + let path = http::uri::PathAndQuery::from_static( 4907 4907 + "/rockbox.v1alpha1.PlaylistService/RemoveTracks", 4908 4908 + ); 4909 4909 + let mut req = request.into_request(); 4910 4910 + req.extensions_mut() 4911 4911 + .insert( 4912 4912 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "RemoveTracks"), 4913 4913 + ); 4914 4914 + self.inner.unary(req, path, codec).await 4915 4915 + } 4916 4916 + pub async fn create_playlist( 4917 4917 + &mut self, 4918 4918 + request: impl tonic::IntoRequest<super::CreatePlaylistRequest>, 4919 4919 + ) -> std::result::Result< 4920 4920 + tonic::Response<super::CreatePlaylistResponse>, 4921 4921 + tonic::Status, 4922 4922 + > { 4923 4923 + self.inner 4924 4924 + .ready() 4925 4925 + .await 4926 4926 + .map_err(|e| { 4927 4927 + tonic::Status::unknown( 4928 4928 + format!("Service was not ready: {}", e.into()), 4929 4929 + ) 4930 4930 + })?; 4931 4931 + let codec = tonic::codec::ProstCodec::default(); 4932 4932 + let path = http::uri::PathAndQuery::from_static( 4933 4933 + "/rockbox.v1alpha1.PlaylistService/CreatePlaylist", 4934 4934 + ); 4935 4935 + let mut req = request.into_request(); 4936 4936 + req.extensions_mut() 4937 4937 + .insert( 4938 4938 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "CreatePlaylist"), 4939 4939 + ); 4940 4940 + self.inner.unary(req, path, codec).await 4941 4941 + } 4942 4942 + pub async fn insert_tracks( 4943 4943 + &mut self, 4944 4944 + request: impl tonic::IntoRequest<super::InsertTracksRequest>, 4945 4945 + ) -> std::result::Result< 4946 4946 + tonic::Response<super::InsertTracksResponse>, 4947 4947 + tonic::Status, 4948 4948 + > { 4949 4949 + self.inner 4950 4950 + .ready() 4951 4951 + .await 4952 4952 + .map_err(|e| { 4953 4953 + tonic::Status::unknown( 4954 4954 + format!("Service was not ready: {}", e.into()), 4955 4955 + ) 4956 4956 + })?; 4957 4957 + let codec = tonic::codec::ProstCodec::default(); 4958 4958 + let path = http::uri::PathAndQuery::from_static( 4959 4959 + "/rockbox.v1alpha1.PlaylistService/InsertTracks", 4960 4960 + ); 4961 4961 + let mut req = request.into_request(); 4962 4962 + req.extensions_mut() 4963 4963 + .insert( 4964 4964 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertTracks"), 4965 4965 + ); 4966 4966 + self.inner.unary(req, path, codec).await 4967 4967 + } 4968 4968 + pub async fn insert_directory( 4969 4969 + &mut self, 4970 4970 + request: impl tonic::IntoRequest<super::InsertDirectoryRequest>, 4971 4971 + ) -> std::result::Result< 4972 4972 + tonic::Response<super::InsertDirectoryResponse>, 4973 4973 + tonic::Status, 4974 4974 + > { 4975 4975 + self.inner 4976 4976 + .ready() 4977 4977 + .await 4978 4978 + .map_err(|e| { 4979 4979 + tonic::Status::unknown( 4980 4980 + format!("Service was not ready: {}", e.into()), 4981 4981 + ) 4982 4982 + })?; 4983 4983 + let codec = tonic::codec::ProstCodec::default(); 4984 4984 + let path = http::uri::PathAndQuery::from_static( 4985 4985 + "/rockbox.v1alpha1.PlaylistService/InsertDirectory", 4986 4986 + ); 4987 4987 + let mut req = request.into_request(); 4988 4988 + req.extensions_mut() 4989 4989 + .insert( 4990 4990 + GrpcMethod::new( 4991 4991 + "rockbox.v1alpha1.PlaylistService", 4992 4992 + "InsertDirectory", 4993 4993 + ), 4994 4994 + ); 4995 4995 + self.inner.unary(req, path, codec).await 4996 4996 + } 4997 4997 + pub async fn insert_playlist( 4998 4998 + &mut self, 4999 4999 + request: impl tonic::IntoRequest<super::InsertPlaylistRequest>, 5000 5000 + ) -> std::result::Result< 5001 5001 + tonic::Response<super::InsertPlaylistResponse>, 5002 5002 + tonic::Status, 5003 5003 + > { 5004 5004 + self.inner 5005 5005 + .ready() 5006 5006 + .await 5007 5007 + .map_err(|e| { 5008 5008 + tonic::Status::unknown( 5009 5009 + format!("Service was not ready: {}", e.into()), 5010 5010 + ) 5011 5011 + })?; 5012 5012 + let codec = tonic::codec::ProstCodec::default(); 5013 5013 + let path = http::uri::PathAndQuery::from_static( 5014 5014 + "/rockbox.v1alpha1.PlaylistService/InsertPlaylist", 5015 5015 + ); 5016 5016 + let mut req = request.into_request(); 5017 5017 + req.extensions_mut() 5018 5018 + .insert( 5019 5019 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertPlaylist"), 5020 5020 + ); 5021 5021 + self.inner.unary(req, path, codec).await 5022 5022 + } 5023 5023 + pub async fn insert_album( 5024 5024 + &mut self, 5025 5025 + request: impl tonic::IntoRequest<super::InsertAlbumRequest>, 5026 5026 + ) -> std::result::Result< 5027 5027 + tonic::Response<super::InsertAlbumResponse>, 5028 5028 + tonic::Status, 5029 5029 + > { 5030 5030 + self.inner 5031 5031 + .ready() 5032 5032 + .await 5033 5033 + .map_err(|e| { 5034 5034 + tonic::Status::unknown( 5035 5035 + format!("Service was not ready: {}", e.into()), 5036 5036 + ) 5037 5037 + })?; 5038 5038 + let codec = tonic::codec::ProstCodec::default(); 5039 5039 + let path = http::uri::PathAndQuery::from_static( 5040 5040 + "/rockbox.v1alpha1.PlaylistService/InsertAlbum", 5041 5041 + ); 5042 5042 + let mut req = request.into_request(); 5043 5043 + req.extensions_mut() 5044 5044 + .insert( 5045 5045 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertAlbum"), 5046 5046 + ); 5047 5047 + self.inner.unary(req, path, codec).await 5048 5048 + } 5049 5049 + pub async fn insert_artist_tracks( 5050 5050 + &mut self, 5051 5051 + request: impl tonic::IntoRequest<super::InsertArtistTracksRequest>, 5052 5052 + ) -> std::result::Result< 5053 5053 + tonic::Response<super::InsertArtistTracksResponse>, 5054 5054 + tonic::Status, 5055 5055 + > { 5056 5056 + self.inner 5057 5057 + .ready() 5058 5058 + .await 5059 5059 + .map_err(|e| { 5060 5060 + tonic::Status::unknown( 5061 5061 + format!("Service was not ready: {}", e.into()), 5062 5062 + ) 5063 5063 + })?; 5064 5064 + let codec = tonic::codec::ProstCodec::default(); 5065 5065 + let path = http::uri::PathAndQuery::from_static( 5066 5066 + "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks", 5067 5067 + ); 5068 5068 + let mut req = request.into_request(); 5069 5069 + req.extensions_mut() 5070 5070 + .insert( 5071 5071 + GrpcMethod::new( 5072 5072 + "rockbox.v1alpha1.PlaylistService", 5073 5073 + "InsertArtistTracks", 5074 5074 + ), 5075 5075 + ); 5076 5076 + self.inner.unary(req, path, codec).await 5077 5077 + } 5078 5078 + pub async fn shuffle_playlist( 5079 5079 + &mut self, 5080 5080 + request: impl tonic::IntoRequest<super::ShufflePlaylistRequest>, 5081 5081 + ) -> std::result::Result< 5082 5082 + tonic::Response<super::ShufflePlaylistResponse>, 5083 5083 + tonic::Status, 5084 5084 + > { 5085 5085 + self.inner 5086 5086 + .ready() 5087 5087 + .await 5088 5088 + .map_err(|e| { 5089 5089 + tonic::Status::unknown( 5090 5090 + format!("Service was not ready: {}", e.into()), 5091 5091 + ) 5092 5092 + })?; 5093 5093 + let codec = tonic::codec::ProstCodec::default(); 5094 5094 + let path = http::uri::PathAndQuery::from_static( 5095 5095 + "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist", 5096 5096 + ); 5097 5097 + let mut req = request.into_request(); 5098 5098 + req.extensions_mut() 5099 5099 + .insert( 5100 5100 + GrpcMethod::new( 5101 5101 + "rockbox.v1alpha1.PlaylistService", 5102 5102 + "ShufflePlaylist", 5103 5103 + ), 5104 5104 + ); 5105 5105 + self.inner.unary(req, path, codec).await 5106 5106 + } 5107 5107 + } 5108 5108 + } 5109 5109 + /// Generated server implementations. 5110 5110 + pub mod playlist_service_server { 5111 5111 + #![allow( 5112 5112 + unused_variables, 5113 5113 + dead_code, 5114 5114 + missing_docs, 5115 5115 + clippy::wildcard_imports, 5116 5116 + clippy::let_unit_value, 5117 5117 + )] 5118 5118 + use tonic::codegen::*; 5119 5119 + /// Generated trait containing gRPC methods that should be implemented for use with PlaylistServiceServer. 5120 5120 + #[async_trait] 5121 5121 + pub trait PlaylistService: std::marker::Send + std::marker::Sync + 'static { 5122 5122 + async fn get_current( 5123 5123 + &self, 5124 5124 + request: tonic::Request<super::GetCurrentRequest>, 5125 5125 + ) -> std::result::Result< 5126 5126 + tonic::Response<super::GetCurrentResponse>, 5127 5127 + tonic::Status, 5128 5128 + >; 5129 5129 + async fn get_resume_info( 5130 5130 + &self, 5131 5131 + request: tonic::Request<super::GetResumeInfoRequest>, 5132 5132 + ) -> std::result::Result< 5133 5133 + tonic::Response<super::GetResumeInfoResponse>, 5134 5134 + tonic::Status, 5135 5135 + >; 5136 5136 + async fn get_track_info( 5137 5137 + &self, 5138 5138 + request: tonic::Request<super::GetTrackInfoRequest>, 5139 5139 + ) -> std::result::Result< 5140 5140 + tonic::Response<super::GetTrackInfoResponse>, 5141 5141 + tonic::Status, 5142 5142 + >; 5143 5143 + async fn get_first_index( 5144 5144 + &self, 5145 5145 + request: tonic::Request<super::GetFirstIndexRequest>, 5146 5146 + ) -> std::result::Result< 5147 5147 + tonic::Response<super::GetFirstIndexResponse>, 5148 5148 + tonic::Status, 5149 5149 + >; 5150 5150 + async fn get_display_index( 5151 5151 + &self, 5152 5152 + request: tonic::Request<super::GetDisplayIndexRequest>, 5153 5153 + ) -> std::result::Result< 5154 5154 + tonic::Response<super::GetDisplayIndexResponse>, 5155 5155 + tonic::Status, 5156 5156 + >; 5157 5157 + async fn amount( 5158 5158 + &self, 5159 5159 + request: tonic::Request<super::AmountRequest>, 5160 5160 + ) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status>; 5161 5161 + async fn playlist_resume( 5162 5162 + &self, 5163 5163 + request: tonic::Request<super::PlaylistResumeRequest>, 5164 5164 + ) -> std::result::Result< 5165 5165 + tonic::Response<super::PlaylistResumeResponse>, 5166 5166 + tonic::Status, 5167 5167 + >; 5168 5168 + async fn resume_track( 5169 5169 + &self, 5170 5170 + request: tonic::Request<super::ResumeTrackRequest>, 5171 5171 + ) -> std::result::Result< 5172 5172 + tonic::Response<super::ResumeTrackResponse>, 5173 5173 + tonic::Status, 5174 5174 + >; 5175 5175 + async fn set_modified( 5176 5176 + &self, 5177 5177 + request: tonic::Request<super::SetModifiedRequest>, 5178 5178 + ) -> std::result::Result< 5179 5179 + tonic::Response<super::SetModifiedResponse>, 5180 5180 + tonic::Status, 5181 5181 + >; 5182 5182 + async fn start( 5183 5183 + &self, 5184 5184 + request: tonic::Request<super::StartRequest>, 5185 5185 + ) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status>; 5186 5186 + async fn sync( 5187 5187 + &self, 5188 5188 + request: tonic::Request<super::SyncRequest>, 5189 5189 + ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status>; 5190 5190 + async fn remove_all_tracks( 5191 5191 + &self, 5192 5192 + request: tonic::Request<super::RemoveAllTracksRequest>, 5193 5193 + ) -> std::result::Result< 5194 5194 + tonic::Response<super::RemoveAllTracksResponse>, 5195 5195 + tonic::Status, 5196 5196 + >; 5197 5197 + async fn remove_tracks( 5198 5198 + &self, 5199 5199 + request: tonic::Request<super::RemoveTracksRequest>, 5200 5200 + ) -> std::result::Result< 5201 5201 + tonic::Response<super::RemoveTracksResponse>, 5202 5202 + tonic::Status, 5203 5203 + >; 5204 5204 + async fn create_playlist( 5205 5205 + &self, 5206 5206 + request: tonic::Request<super::CreatePlaylistRequest>, 5207 5207 + ) -> std::result::Result< 5208 5208 + tonic::Response<super::CreatePlaylistResponse>, 5209 5209 + tonic::Status, 5210 5210 + >; 5211 5211 + async fn insert_tracks( 5212 5212 + &self, 5213 5213 + request: tonic::Request<super::InsertTracksRequest>, 5214 5214 + ) -> std::result::Result< 5215 5215 + tonic::Response<super::InsertTracksResponse>, 5216 5216 + tonic::Status, 5217 5217 + >; 5218 5218 + async fn insert_directory( 5219 5219 + &self, 5220 5220 + request: tonic::Request<super::InsertDirectoryRequest>, 5221 5221 + ) -> std::result::Result< 5222 5222 + tonic::Response<super::InsertDirectoryResponse>, 5223 5223 + tonic::Status, 5224 5224 + >; 5225 5225 + async fn insert_playlist( 5226 5226 + &self, 5227 5227 + request: tonic::Request<super::InsertPlaylistRequest>, 5228 5228 + ) -> std::result::Result< 5229 5229 + tonic::Response<super::InsertPlaylistResponse>, 5230 5230 + tonic::Status, 5231 5231 + >; 5232 5232 + async fn insert_album( 5233 5233 + &self, 5234 5234 + request: tonic::Request<super::InsertAlbumRequest>, 5235 5235 + ) -> std::result::Result< 5236 5236 + tonic::Response<super::InsertAlbumResponse>, 5237 5237 + tonic::Status, 5238 5238 + >; 5239 5239 + async fn insert_artist_tracks( 5240 5240 + &self, 5241 5241 + request: tonic::Request<super::InsertArtistTracksRequest>, 5242 5242 + ) -> std::result::Result< 5243 5243 + tonic::Response<super::InsertArtistTracksResponse>, 5244 5244 + tonic::Status, 5245 5245 + >; 5246 5246 + async fn shuffle_playlist( 5247 5247 + &self, 5248 5248 + request: tonic::Request<super::ShufflePlaylistRequest>, 5249 5249 + ) -> std::result::Result< 5250 5250 + tonic::Response<super::ShufflePlaylistResponse>, 5251 5251 + tonic::Status, 5252 5252 + >; 5253 5253 + } 5254 5254 + #[derive(Debug)] 5255 5255 + pub struct PlaylistServiceServer<T> { 5256 5256 + inner: Arc<T>, 5257 5257 + accept_compression_encodings: EnabledCompressionEncodings, 5258 5258 + send_compression_encodings: EnabledCompressionEncodings, 5259 5259 + max_decoding_message_size: Option<usize>, 5260 5260 + max_encoding_message_size: Option<usize>, 5261 5261 + } 5262 5262 + impl<T> PlaylistServiceServer<T> { 5263 5263 + pub fn new(inner: T) -> Self { 5264 5264 + Self::from_arc(Arc::new(inner)) 5265 5265 + } 5266 5266 + pub fn from_arc(inner: Arc<T>) -> Self { 5267 5267 + Self { 5268 5268 + inner, 5269 5269 + accept_compression_encodings: Default::default(), 5270 5270 + send_compression_encodings: Default::default(), 5271 5271 + max_decoding_message_size: None, 5272 5272 + max_encoding_message_size: None, 5273 5273 + } 5274 5274 + } 5275 5275 + pub fn with_interceptor<F>( 5276 5276 + inner: T, 5277 5277 + interceptor: F, 5278 5278 + ) -> InterceptedService<Self, F> 5279 5279 + where 5280 5280 + F: tonic::service::Interceptor, 5281 5281 + { 5282 5282 + InterceptedService::new(Self::new(inner), interceptor) 5283 5283 + } 5284 5284 + /// Enable decompressing requests with the given encoding. 5285 5285 + #[must_use] 5286 5286 + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { 5287 5287 + self.accept_compression_encodings.enable(encoding); 5288 5288 + self 5289 5289 + } 5290 5290 + /// Compress responses with the given encoding, if the client supports it. 5291 5291 + #[must_use] 5292 5292 + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { 5293 5293 + self.send_compression_encodings.enable(encoding); 5294 5294 + self 5295 5295 + } 5296 5296 + /// Limits the maximum size of a decoded message. 5297 5297 + /// 5298 5298 + /// Default: `4MB` 5299 5299 + #[must_use] 5300 5300 + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { 5301 5301 + self.max_decoding_message_size = Some(limit); 5302 5302 + self 5303 5303 + } 5304 5304 + /// Limits the maximum size of an encoded message. 5305 5305 + /// 5306 5306 + /// Default: `usize::MAX` 5307 5307 + #[must_use] 5308 5308 + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { 5309 5309 + self.max_encoding_message_size = Some(limit); 5310 5310 + self 5311 5311 + } 5312 5312 + } 5313 5313 + impl<T, B> tonic::codegen::Service<http::Request<B>> for PlaylistServiceServer<T> 5314 5314 + where 5315 5315 + T: PlaylistService, 5316 5316 + B: Body + std::marker::Send + 'static, 5317 5317 + B::Error: Into<StdError> + std::marker::Send + 'static, 5318 5318 + { 5319 5319 + type Response = http::Response<tonic::body::BoxBody>; 5320 5320 + type Error = std::convert::Infallible; 5321 5321 + type Future = BoxFuture<Self::Response, Self::Error>; 5322 5322 + fn poll_ready( 5323 5323 + &mut self, 5324 5324 + _cx: &mut Context<'_>, 5325 5325 + ) -> Poll<std::result::Result<(), Self::Error>> { 5326 5326 + Poll::Ready(Ok(())) 5327 5327 + } 5328 5328 + fn call(&mut self, req: http::Request<B>) -> Self::Future { 5329 5329 + match req.uri().path() { 5330 5330 + "/rockbox.v1alpha1.PlaylistService/GetCurrent" => { 5331 5331 + #[allow(non_camel_case_types)] 5332 5332 + struct GetCurrentSvc<T: PlaylistService>(pub Arc<T>); 5333 5333 + impl< 5334 5334 + T: PlaylistService, 5335 5335 + > tonic::server::UnaryService<super::GetCurrentRequest> 5336 5336 + for GetCurrentSvc<T> { 5337 5337 + type Response = super::GetCurrentResponse; 5338 5338 + type Future = BoxFuture< 5339 5339 + tonic::Response<Self::Response>, 5340 5340 + tonic::Status, 5341 5341 + >; 5342 5342 + fn call( 5343 5343 + &mut self, 5344 5344 + request: tonic::Request<super::GetCurrentRequest>, 5345 5345 + ) -> Self::Future { 5346 5346 + let inner = Arc::clone(&self.0); 5347 5347 + let fut = async move { 5348 5348 + <T as PlaylistService>::get_current(&inner, request).await 5349 5349 + }; 5350 5350 + Box::pin(fut) 5351 5351 + } 5352 5352 + } 5353 5353 + let accept_compression_encodings = self.accept_compression_encodings; 5354 5354 + let send_compression_encodings = self.send_compression_encodings; 5355 5355 + let max_decoding_message_size = self.max_decoding_message_size; 5356 5356 + let max_encoding_message_size = self.max_encoding_message_size; 5357 5357 + let inner = self.inner.clone(); 5358 5358 + let fut = async move { 5359 5359 + let method = GetCurrentSvc(inner); 5360 5360 + let codec = tonic::codec::ProstCodec::default(); 5361 5361 + let mut grpc = tonic::server::Grpc::new(codec) 5362 5362 + .apply_compression_config( 5363 5363 + accept_compression_encodings, 5364 5364 + send_compression_encodings, 5365 5365 + ) 5366 5366 + .apply_max_message_size_config( 5367 5367 + max_decoding_message_size, 5368 5368 + max_encoding_message_size, 5369 5369 + ); 5370 5370 + let res = grpc.unary(method, req).await; 5371 5371 + Ok(res) 5372 5372 + }; 5373 5373 + Box::pin(fut) 5374 5374 + } 5375 5375 + "/rockbox.v1alpha1.PlaylistService/GetResumeInfo" => { 5376 5376 + #[allow(non_camel_case_types)] 5377 5377 + struct GetResumeInfoSvc<T: PlaylistService>(pub Arc<T>); 5378 5378 + impl< 5379 5379 + T: PlaylistService, 5380 5380 + > tonic::server::UnaryService<super::GetResumeInfoRequest> 5381 5381 + for GetResumeInfoSvc<T> { 5382 5382 + type Response = super::GetResumeInfoResponse; 5383 5383 + type Future = BoxFuture< 5384 5384 + tonic::Response<Self::Response>, 5385 5385 + tonic::Status, 5386 5386 + >; 5387 5387 + fn call( 5388 5388 + &mut self, 5389 5389 + request: tonic::Request<super::GetResumeInfoRequest>, 5390 5390 + ) -> Self::Future { 5391 5391 + let inner = Arc::clone(&self.0); 5392 5392 + let fut = async move { 5393 5393 + <T as PlaylistService>::get_resume_info(&inner, request) 5394 5394 + .await 5395 5395 + }; 5396 5396 + Box::pin(fut) 5397 5397 + } 5398 5398 + } 5399 5399 + let accept_compression_encodings = self.accept_compression_encodings; 5400 5400 + let send_compression_encodings = self.send_compression_encodings; 5401 5401 + let max_decoding_message_size = self.max_decoding_message_size; 5402 5402 + let max_encoding_message_size = self.max_encoding_message_size; 5403 5403 + let inner = self.inner.clone(); 5404 5404 + let fut = async move { 5405 5405 + let method = GetResumeInfoSvc(inner); 5406 5406 + let codec = tonic::codec::ProstCodec::default(); 5407 5407 + let mut grpc = tonic::server::Grpc::new(codec) 5408 5408 + .apply_compression_config( 5409 5409 + accept_compression_encodings, 5410 5410 + send_compression_encodings, 5411 5411 + ) 5412 5412 + .apply_max_message_size_config( 5413 5413 + max_decoding_message_size, 5414 5414 + max_encoding_message_size, 5415 5415 + ); 5416 5416 + let res = grpc.unary(method, req).await; 5417 5417 + Ok(res) 5418 5418 + }; 5419 5419 + Box::pin(fut) 5420 5420 + } 5421 5421 + "/rockbox.v1alpha1.PlaylistService/GetTrackInfo" => { 5422 5422 + #[allow(non_camel_case_types)] 5423 5423 + struct GetTrackInfoSvc<T: PlaylistService>(pub Arc<T>); 5424 5424 + impl< 5425 5425 + T: PlaylistService, 5426 5426 + > tonic::server::UnaryService<super::GetTrackInfoRequest> 5427 5427 + for GetTrackInfoSvc<T> { 5428 5428 + type Response = super::GetTrackInfoResponse; 5429 5429 + type Future = BoxFuture< 5430 5430 + tonic::Response<Self::Response>, 5431 5431 + tonic::Status, 5432 5432 + >; 5433 5433 + fn call( 5434 5434 + &mut self, 5435 5435 + request: tonic::Request<super::GetTrackInfoRequest>, 5436 5436 + ) -> Self::Future { 5437 5437 + let inner = Arc::clone(&self.0); 5438 5438 + let fut = async move { 5439 5439 + <T as PlaylistService>::get_track_info(&inner, request) 5440 5440 + .await 5441 5441 + }; 5442 5442 + Box::pin(fut) 5443 5443 + } 5444 5444 + } 5445 5445 + let accept_compression_encodings = self.accept_compression_encodings; 5446 5446 + let send_compression_encodings = self.send_compression_encodings; 5447 5447 + let max_decoding_message_size = self.max_decoding_message_size; 5448 5448 + let max_encoding_message_size = self.max_encoding_message_size; 5449 5449 + let inner = self.inner.clone(); 5450 5450 + let fut = async move { 5451 5451 + let method = GetTrackInfoSvc(inner); 5452 5452 + let codec = tonic::codec::ProstCodec::default(); 5453 5453 + let mut grpc = tonic::server::Grpc::new(codec) 5454 5454 + .apply_compression_config( 5455 5455 + accept_compression_encodings, 5456 5456 + send_compression_encodings, 5457 5457 + ) 5458 5458 + .apply_max_message_size_config( 5459 5459 + max_decoding_message_size, 5460 5460 + max_encoding_message_size, 5461 5461 + ); 5462 5462 + let res = grpc.unary(method, req).await; 5463 5463 + Ok(res) 5464 5464 + }; 5465 5465 + Box::pin(fut) 5466 5466 + } 5467 5467 + "/rockbox.v1alpha1.PlaylistService/GetFirstIndex" => { 5468 5468 + #[allow(non_camel_case_types)] 5469 5469 + struct GetFirstIndexSvc<T: PlaylistService>(pub Arc<T>); 5470 5470 + impl< 5471 5471 + T: PlaylistService, 5472 5472 + > tonic::server::UnaryService<super::GetFirstIndexRequest> 5473 5473 + for GetFirstIndexSvc<T> { 5474 5474 + type Response = super::GetFirstIndexResponse; 5475 5475 + type Future = BoxFuture< 5476 5476 + tonic::Response<Self::Response>, 5477 5477 + tonic::Status, 5478 5478 + >; 5479 5479 + fn call( 5480 5480 + &mut self, 5481 5481 + request: tonic::Request<super::GetFirstIndexRequest>, 5482 5482 + ) -> Self::Future { 5483 5483 + let inner = Arc::clone(&self.0); 5484 5484 + let fut = async move { 5485 5485 + <T as PlaylistService>::get_first_index(&inner, request) 5486 5486 + .await 5487 5487 + }; 5488 5488 + Box::pin(fut) 5489 5489 + } 5490 5490 + } 5491 5491 + let accept_compression_encodings = self.accept_compression_encodings; 5492 5492 + let send_compression_encodings = self.send_compression_encodings; 5493 5493 + let max_decoding_message_size = self.max_decoding_message_size; 5494 5494 + let max_encoding_message_size = self.max_encoding_message_size; 5495 5495 + let inner = self.inner.clone(); 5496 5496 + let fut = async move { 5497 5497 + let method = GetFirstIndexSvc(inner); 5498 5498 + let codec = tonic::codec::ProstCodec::default(); 5499 5499 + let mut grpc = tonic::server::Grpc::new(codec) 5500 5500 + .apply_compression_config( 5501 5501 + accept_compression_encodings, 5502 5502 + send_compression_encodings, 5503 5503 + ) 5504 5504 + .apply_max_message_size_config( 5505 5505 + max_decoding_message_size, 5506 5506 + max_encoding_message_size, 5507 5507 + ); 5508 5508 + let res = grpc.unary(method, req).await; 5509 5509 + Ok(res) 5510 5510 + }; 5511 5511 + Box::pin(fut) 5512 5512 + } 5513 5513 + "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex" => { 5514 5514 + #[allow(non_camel_case_types)] 5515 5515 + struct GetDisplayIndexSvc<T: PlaylistService>(pub Arc<T>); 5516 5516 + impl< 5517 5517 + T: PlaylistService, 5518 5518 + > tonic::server::UnaryService<super::GetDisplayIndexRequest> 5519 5519 + for GetDisplayIndexSvc<T> { 5520 5520 + type Response = super::GetDisplayIndexResponse; 5521 5521 + type Future = BoxFuture< 5522 5522 + tonic::Response<Self::Response>, 5523 5523 + tonic::Status, 5524 5524 + >; 5525 5525 + fn call( 5526 5526 + &mut self, 5527 5527 + request: tonic::Request<super::GetDisplayIndexRequest>, 5528 5528 + ) -> Self::Future { 5529 5529 + let inner = Arc::clone(&self.0); 5530 5530 + let fut = async move { 5531 5531 + <T as PlaylistService>::get_display_index(&inner, request) 5532 5532 + .await 5533 5533 + }; 5534 5534 + Box::pin(fut) 5535 5535 + } 5536 5536 + } 5537 5537 + let accept_compression_encodings = self.accept_compression_encodings; 5538 5538 + let send_compression_encodings = self.send_compression_encodings; 5539 5539 + let max_decoding_message_size = self.max_decoding_message_size; 5540 5540 + let max_encoding_message_size = self.max_encoding_message_size; 5541 5541 + let inner = self.inner.clone(); 5542 5542 + let fut = async move { 5543 5543 + let method = GetDisplayIndexSvc(inner); 5544 5544 + let codec = tonic::codec::ProstCodec::default(); 5545 5545 + let mut grpc = tonic::server::Grpc::new(codec) 5546 5546 + .apply_compression_config( 5547 5547 + accept_compression_encodings, 5548 5548 + send_compression_encodings, 5549 5549 + ) 5550 5550 + .apply_max_message_size_config( 5551 5551 + max_decoding_message_size, 5552 5552 + max_encoding_message_size, 5553 5553 + ); 5554 5554 + let res = grpc.unary(method, req).await; 5555 5555 + Ok(res) 5556 5556 + }; 5557 5557 + Box::pin(fut) 5558 5558 + } 5559 5559 + "/rockbox.v1alpha1.PlaylistService/Amount" => { 5560 5560 + #[allow(non_camel_case_types)] 5561 5561 + struct AmountSvc<T: PlaylistService>(pub Arc<T>); 5562 5562 + impl< 5563 5563 + T: PlaylistService, 5564 5564 + > tonic::server::UnaryService<super::AmountRequest> 5565 5565 + for AmountSvc<T> { 5566 5566 + type Response = super::AmountResponse; 5567 5567 + type Future = BoxFuture< 5568 5568 + tonic::Response<Self::Response>, 5569 5569 + tonic::Status, 5570 5570 + >; 5571 5571 + fn call( 5572 5572 + &mut self, 5573 5573 + request: tonic::Request<super::AmountRequest>, 5574 5574 + ) -> Self::Future { 5575 5575 + let inner = Arc::clone(&self.0); 5576 5576 + let fut = async move { 5577 5577 + <T as PlaylistService>::amount(&inner, request).await 5578 5578 + }; 5579 5579 + Box::pin(fut) 5580 5580 + } 5581 5581 + } 5582 5582 + let accept_compression_encodings = self.accept_compression_encodings; 5583 5583 + let send_compression_encodings = self.send_compression_encodings; 5584 5584 + let max_decoding_message_size = self.max_decoding_message_size; 5585 5585 + let max_encoding_message_size = self.max_encoding_message_size; 5586 5586 + let inner = self.inner.clone(); 5587 5587 + let fut = async move { 5588 5588 + let method = AmountSvc(inner); 5589 5589 + let codec = tonic::codec::ProstCodec::default(); 5590 5590 + let mut grpc = tonic::server::Grpc::new(codec) 5591 5591 + .apply_compression_config( 5592 5592 + accept_compression_encodings, 5593 5593 + send_compression_encodings, 5594 5594 + ) 5595 5595 + .apply_max_message_size_config( 5596 5596 + max_decoding_message_size, 5597 5597 + max_encoding_message_size, 5598 5598 + ); 5599 5599 + let res = grpc.unary(method, req).await; 5600 5600 + Ok(res) 5601 5601 + }; 5602 5602 + Box::pin(fut) 5603 5603 + } 5604 5604 + "/rockbox.v1alpha1.PlaylistService/PlaylistResume" => { 5605 5605 + #[allow(non_camel_case_types)] 5606 5606 + struct PlaylistResumeSvc<T: PlaylistService>(pub Arc<T>); 5607 5607 + impl< 5608 5608 + T: PlaylistService, 5609 5609 + > tonic::server::UnaryService<super::PlaylistResumeRequest> 5610 5610 + for PlaylistResumeSvc<T> { 5611 5611 + type Response = super::PlaylistResumeResponse; 5612 5612 + type Future = BoxFuture< 5613 5613 + tonic::Response<Self::Response>, 5614 5614 + tonic::Status, 5615 5615 + >; 5616 5616 + fn call( 5617 5617 + &mut self, 5618 5618 + request: tonic::Request<super::PlaylistResumeRequest>, 5619 5619 + ) -> Self::Future { 5620 5620 + let inner = Arc::clone(&self.0); 5621 5621 + let fut = async move { 5622 5622 + <T as PlaylistService>::playlist_resume(&inner, request) 5623 5623 + .await 5624 5624 + }; 5625 5625 + Box::pin(fut) 5626 5626 + } 5627 5627 + } 5628 5628 + let accept_compression_encodings = self.accept_compression_encodings; 5629 5629 + let send_compression_encodings = self.send_compression_encodings; 5630 5630 + let max_decoding_message_size = self.max_decoding_message_size; 5631 5631 + let max_encoding_message_size = self.max_encoding_message_size; 5632 5632 + let inner = self.inner.clone(); 5633 5633 + let fut = async move { 5634 5634 + let method = PlaylistResumeSvc(inner); 5635 5635 + let codec = tonic::codec::ProstCodec::default(); 5636 5636 + let mut grpc = tonic::server::Grpc::new(codec) 5637 5637 + .apply_compression_config( 5638 5638 + accept_compression_encodings, 5639 5639 + send_compression_encodings, 5640 5640 + ) 5641 5641 + .apply_max_message_size_config( 5642 5642 + max_decoding_message_size, 5643 5643 + max_encoding_message_size, 5644 5644 + ); 5645 5645 + let res = grpc.unary(method, req).await; 5646 5646 + Ok(res) 5647 5647 + }; 5648 5648 + Box::pin(fut) 5649 5649 + } 5650 5650 + "/rockbox.v1alpha1.PlaylistService/ResumeTrack" => { 5651 5651 + #[allow(non_camel_case_types)] 5652 5652 + struct ResumeTrackSvc<T: PlaylistService>(pub Arc<T>); 5653 5653 + impl< 5654 5654 + T: PlaylistService, 5655 5655 + > tonic::server::UnaryService<super::ResumeTrackRequest> 5656 5656 + for ResumeTrackSvc<T> { 5657 5657 + type Response = super::ResumeTrackResponse; 5658 5658 + type Future = BoxFuture< 5659 5659 + tonic::Response<Self::Response>, 5660 5660 + tonic::Status, 5661 5661 + >; 5662 5662 + fn call( 5663 5663 + &mut self, 5664 5664 + request: tonic::Request<super::ResumeTrackRequest>, 5665 5665 + ) -> Self::Future { 5666 5666 + let inner = Arc::clone(&self.0); 5667 5667 + let fut = async move { 5668 5668 + <T as PlaylistService>::resume_track(&inner, request).await 5669 5669 + }; 5670 5670 + Box::pin(fut) 5671 5671 + } 5672 5672 + } 5673 5673 + let accept_compression_encodings = self.accept_compression_encodings; 5674 5674 + let send_compression_encodings = self.send_compression_encodings; 5675 5675 + let max_decoding_message_size = self.max_decoding_message_size; 5676 5676 + let max_encoding_message_size = self.max_encoding_message_size; 5677 5677 + let inner = self.inner.clone(); 5678 5678 + let fut = async move { 5679 5679 + let method = ResumeTrackSvc(inner); 5680 5680 + let codec = tonic::codec::ProstCodec::default(); 5681 5681 + let mut grpc = tonic::server::Grpc::new(codec) 5682 5682 + .apply_compression_config( 5683 5683 + accept_compression_encodings, 5684 5684 + send_compression_encodings, 5685 5685 + ) 5686 5686 + .apply_max_message_size_config( 5687 5687 + max_decoding_message_size, 5688 5688 + max_encoding_message_size, 5689 5689 + ); 5690 5690 + let res = grpc.unary(method, req).await; 5691 5691 + Ok(res) 5692 5692 + }; 5693 5693 + Box::pin(fut) 5694 5694 + } 5695 5695 + "/rockbox.v1alpha1.PlaylistService/SetModified" => { 5696 5696 + #[allow(non_camel_case_types)] 5697 5697 + struct SetModifiedSvc<T: PlaylistService>(pub Arc<T>); 5698 5698 + impl< 5699 5699 + T: PlaylistService, 5700 5700 + > tonic::server::UnaryService<super::SetModifiedRequest> 5701 5701 + for SetModifiedSvc<T> { 5702 5702 + type Response = super::SetModifiedResponse; 5703 5703 + type Future = BoxFuture< 5704 5704 + tonic::Response<Self::Response>, 5705 5705 + tonic::Status, 5706 5706 + >; 5707 5707 + fn call( 5708 5708 + &mut self, 5709 5709 + request: tonic::Request<super::SetModifiedRequest>, 5710 5710 + ) -> Self::Future { 5711 5711 + let inner = Arc::clone(&self.0); 5712 5712 + let fut = async move { 5713 5713 + <T as PlaylistService>::set_modified(&inner, request).await 5714 5714 + }; 5715 5715 + Box::pin(fut) 5716 5716 + } 5717 5717 + } 5718 5718 + let accept_compression_encodings = self.accept_compression_encodings; 5719 5719 + let send_compression_encodings = self.send_compression_encodings; 5720 5720 + let max_decoding_message_size = self.max_decoding_message_size; 5721 5721 + let max_encoding_message_size = self.max_encoding_message_size; 5722 5722 + let inner = self.inner.clone(); 5723 5723 + let fut = async move { 5724 5724 + let method = SetModifiedSvc(inner); 5725 5725 + let codec = tonic::codec::ProstCodec::default(); 5726 5726 + let mut grpc = tonic::server::Grpc::new(codec) 5727 5727 + .apply_compression_config( 5728 5728 + accept_compression_encodings, 5729 5729 + send_compression_encodings, 5730 5730 + ) 5731 5731 + .apply_max_message_size_config( 5732 5732 + max_decoding_message_size, 5733 5733 + max_encoding_message_size, 5734 5734 + ); 5735 5735 + let res = grpc.unary(method, req).await; 5736 5736 + Ok(res) 5737 5737 + }; 5738 5738 + Box::pin(fut) 5739 5739 + } 5740 5740 + "/rockbox.v1alpha1.PlaylistService/Start" => { 5741 5741 + #[allow(non_camel_case_types)] 5742 5742 + struct StartSvc<T: PlaylistService>(pub Arc<T>); 5743 5743 + impl< 5744 5744 + T: PlaylistService, 5745 5745 + > tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 5746 5746 + type Response = super::StartResponse; 5747 5747 + type Future = BoxFuture< 5748 5748 + tonic::Response<Self::Response>, 5749 5749 + tonic::Status, 5750 5750 + >; 5751 5751 + fn call( 5752 5752 + &mut self, 5753 5753 + request: tonic::Request<super::StartRequest>, 5754 5754 + ) -> Self::Future { 5755 5755 + let inner = Arc::clone(&self.0); 5756 5756 + let fut = async move { 5757 5757 + <T as PlaylistService>::start(&inner, request).await 5758 5758 + }; 5759 5759 + Box::pin(fut) 5760 5760 + } 5761 5761 + } 5762 5762 + let accept_compression_encodings = self.accept_compression_encodings; 5763 5763 + let send_compression_encodings = self.send_compression_encodings; 5764 5764 + let max_decoding_message_size = self.max_decoding_message_size; 5765 5765 + let max_encoding_message_size = self.max_encoding_message_size; 5766 5766 + let inner = self.inner.clone(); 5767 5767 + let fut = async move { 5768 5768 + let method = StartSvc(inner); 5769 5769 + let codec = tonic::codec::ProstCodec::default(); 5770 5770 + let mut grpc = tonic::server::Grpc::new(codec) 5771 5771 + .apply_compression_config( 5772 5772 + accept_compression_encodings, 5773 5773 + send_compression_encodings, 5774 5774 + ) 5775 5775 + .apply_max_message_size_config( 5776 5776 + max_decoding_message_size, 5777 5777 + max_encoding_message_size, 5778 5778 + ); 5779 5779 + let res = grpc.unary(method, req).await; 5780 5780 + Ok(res) 5781 5781 + }; 5782 5782 + Box::pin(fut) 5783 5783 + } 5784 5784 + "/rockbox.v1alpha1.PlaylistService/Sync" => { 5785 5785 + #[allow(non_camel_case_types)] 5786 5786 + struct SyncSvc<T: PlaylistService>(pub Arc<T>); 5787 5787 + impl< 5788 5788 + T: PlaylistService, 5789 5789 + > tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 5790 5790 + type Response = super::SyncResponse; 5791 5791 + type Future = BoxFuture< 5792 5792 + tonic::Response<Self::Response>, 5793 5793 + tonic::Status, 5794 5794 + >; 5795 5795 + fn call( 5796 5796 + &mut self, 5797 5797 + request: tonic::Request<super::SyncRequest>, 5798 5798 + ) -> Self::Future { 5799 5799 + let inner = Arc::clone(&self.0); 5800 5800 + let fut = async move { 5801 5801 + <T as PlaylistService>::sync(&inner, request).await 5802 5802 + }; 5803 5803 + Box::pin(fut) 5804 5804 + } 5805 5805 + } 5806 5806 + let accept_compression_encodings = self.accept_compression_encodings; 5807 5807 + let send_compression_encodings = self.send_compression_encodings; 5808 5808 + let max_decoding_message_size = self.max_decoding_message_size; 5809 5809 + let max_encoding_message_size = self.max_encoding_message_size; 5810 5810 + let inner = self.inner.clone(); 5811 5811 + let fut = async move { 5812 5812 + let method = SyncSvc(inner); 5813 5813 + let codec = tonic::codec::ProstCodec::default(); 5814 5814 + let mut grpc = tonic::server::Grpc::new(codec) 5815 5815 + .apply_compression_config( 5816 5816 + accept_compression_encodings, 5817 5817 + send_compression_encodings, 5818 5818 + ) 5819 5819 + .apply_max_message_size_config( 5820 5820 + max_decoding_message_size, 5821 5821 + max_encoding_message_size, 5822 5822 + ); 5823 5823 + let res = grpc.unary(method, req).await; 5824 5824 + Ok(res) 5825 5825 + }; 5826 5826 + Box::pin(fut) 5827 5827 + } 5828 5828 + "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks" => { 5829 5829 + #[allow(non_camel_case_types)] 5830 5830 + struct RemoveAllTracksSvc<T: PlaylistService>(pub Arc<T>); 5831 5831 + impl< 5832 5832 + T: PlaylistService, 5833 5833 + > tonic::server::UnaryService<super::RemoveAllTracksRequest> 5834 5834 + for RemoveAllTracksSvc<T> { 5835 5835 + type Response = super::RemoveAllTracksResponse; 5836 5836 + type Future = BoxFuture< 5837 5837 + tonic::Response<Self::Response>, 5838 5838 + tonic::Status, 5839 5839 + >; 5840 5840 + fn call( 5841 5841 + &mut self, 5842 5842 + request: tonic::Request<super::RemoveAllTracksRequest>, 5843 5843 + ) -> Self::Future { 5844 5844 + let inner = Arc::clone(&self.0); 5845 5845 + let fut = async move { 5846 5846 + <T as PlaylistService>::remove_all_tracks(&inner, request) 5847 5847 + .await 5848 5848 + }; 5849 5849 + Box::pin(fut) 5850 5850 + } 5851 5851 + } 5852 5852 + let accept_compression_encodings = self.accept_compression_encodings; 5853 5853 + let send_compression_encodings = self.send_compression_encodings; 5854 5854 + let max_decoding_message_size = self.max_decoding_message_size; 5855 5855 + let max_encoding_message_size = self.max_encoding_message_size; 5856 5856 + let inner = self.inner.clone(); 5857 5857 + let fut = async move { 5858 5858 + let method = RemoveAllTracksSvc(inner); 5859 5859 + let codec = tonic::codec::ProstCodec::default(); 5860 5860 + let mut grpc = tonic::server::Grpc::new(codec) 5861 5861 + .apply_compression_config( 5862 5862 + accept_compression_encodings, 5863 5863 + send_compression_encodings, 5864 5864 + ) 5865 5865 + .apply_max_message_size_config( 5866 5866 + max_decoding_message_size, 5867 5867 + max_encoding_message_size, 5868 5868 + ); 5869 5869 + let res = grpc.unary(method, req).await; 5870 5870 + Ok(res) 5871 5871 + }; 5872 5872 + Box::pin(fut) 5873 5873 + } 5874 5874 + "/rockbox.v1alpha1.PlaylistService/RemoveTracks" => { 5875 5875 + #[allow(non_camel_case_types)] 5876 5876 + struct RemoveTracksSvc<T: PlaylistService>(pub Arc<T>); 5877 5877 + impl< 5878 5878 + T: PlaylistService, 5879 5879 + > tonic::server::UnaryService<super::RemoveTracksRequest> 5880 5880 + for RemoveTracksSvc<T> { 5881 5881 + type Response = super::RemoveTracksResponse; 5882 5882 + type Future = BoxFuture< 5883 5883 + tonic::Response<Self::Response>, 5884 5884 + tonic::Status, 5885 5885 + >; 5886 5886 + fn call( 5887 5887 + &mut self, 5888 5888 + request: tonic::Request<super::RemoveTracksRequest>, 5889 5889 + ) -> Self::Future { 5890 5890 + let inner = Arc::clone(&self.0); 5891 5891 + let fut = async move { 5892 5892 + <T as PlaylistService>::remove_tracks(&inner, request).await 5893 5893 + }; 5894 5894 + Box::pin(fut) 5895 5895 + } 5896 5896 + } 5897 5897 + let accept_compression_encodings = self.accept_compression_encodings; 5898 5898 + let send_compression_encodings = self.send_compression_encodings; 5899 5899 + let max_decoding_message_size = self.max_decoding_message_size; 5900 5900 + let max_encoding_message_size = self.max_encoding_message_size; 5901 5901 + let inner = self.inner.clone(); 5902 5902 + let fut = async move { 5903 5903 + let method = RemoveTracksSvc(inner); 5904 5904 + let codec = tonic::codec::ProstCodec::default(); 5905 5905 + let mut grpc = tonic::server::Grpc::new(codec) 5906 5906 + .apply_compression_config( 5907 5907 + accept_compression_encodings, 5908 5908 + send_compression_encodings, 5909 5909 + ) 5910 5910 + .apply_max_message_size_config( 5911 5911 + max_decoding_message_size, 5912 5912 + max_encoding_message_size, 5913 5913 + ); 5914 5914 + let res = grpc.unary(method, req).await; 5915 5915 + Ok(res) 5916 5916 + }; 5917 5917 + Box::pin(fut) 5918 5918 + } 5919 5919 + "/rockbox.v1alpha1.PlaylistService/CreatePlaylist" => { 5920 5920 + #[allow(non_camel_case_types)] 5921 5921 + struct CreatePlaylistSvc<T: PlaylistService>(pub Arc<T>); 5922 5922 + impl< 5923 5923 + T: PlaylistService, 5924 5924 + > tonic::server::UnaryService<super::CreatePlaylistRequest> 5925 5925 + for CreatePlaylistSvc<T> { 5926 5926 + type Response = super::CreatePlaylistResponse; 5927 5927 + type Future = BoxFuture< 5928 5928 + tonic::Response<Self::Response>, 5929 5929 + tonic::Status, 5930 5930 + >; 5931 5931 + fn call( 5932 5932 + &mut self, 5933 5933 + request: tonic::Request<super::CreatePlaylistRequest>, 5934 5934 + ) -> Self::Future { 5935 5935 + let inner = Arc::clone(&self.0); 5936 5936 + let fut = async move { 5937 5937 + <T as PlaylistService>::create_playlist(&inner, request) 5938 5938 + .await 5939 5939 + }; 5940 5940 + Box::pin(fut) 5941 5941 + } 5942 5942 + } 5943 5943 + let accept_compression_encodings = self.accept_compression_encodings; 5944 5944 + let send_compression_encodings = self.send_compression_encodings; 5945 5945 + let max_decoding_message_size = self.max_decoding_message_size; 5946 5946 + let max_encoding_message_size = self.max_encoding_message_size; 5947 5947 + let inner = self.inner.clone(); 5948 5948 + let fut = async move { 5949 5949 + let method = CreatePlaylistSvc(inner); 5950 5950 + let codec = tonic::codec::ProstCodec::default(); 5951 5951 + let mut grpc = tonic::server::Grpc::new(codec) 5952 5952 + .apply_compression_config( 5953 5953 + accept_compression_encodings, 5954 5954 + send_compression_encodings, 5955 5955 + ) 5956 5956 + .apply_max_message_size_config( 5957 5957 + max_decoding_message_size, 5958 5958 + max_encoding_message_size, 5959 5959 + ); 5960 5960 + let res = grpc.unary(method, req).await; 5961 5961 + Ok(res) 5962 5962 + }; 5963 5963 + Box::pin(fut) 5964 5964 + } 5965 5965 + "/rockbox.v1alpha1.PlaylistService/InsertTracks" => { 5966 5966 + #[allow(non_camel_case_types)] 5967 5967 + struct InsertTracksSvc<T: PlaylistService>(pub Arc<T>); 5968 5968 + impl< 5969 5969 + T: PlaylistService, 5970 5970 + > tonic::server::UnaryService<super::InsertTracksRequest> 5971 5971 + for InsertTracksSvc<T> { 5972 5972 + type Response = super::InsertTracksResponse; 5973 5973 + type Future = BoxFuture< 5974 5974 + tonic::Response<Self::Response>, 5975 5975 + tonic::Status, 5976 5976 + >; 5977 5977 + fn call( 5978 5978 + &mut self, 5979 5979 + request: tonic::Request<super::InsertTracksRequest>, 5980 5980 + ) -> Self::Future { 5981 5981 + let inner = Arc::clone(&self.0); 5982 5982 + let fut = async move { 5983 5983 + <T as PlaylistService>::insert_tracks(&inner, request).await 5984 5984 + }; 5985 5985 + Box::pin(fut) 5986 5986 + } 5987 5987 + } 5988 5988 + let accept_compression_encodings = self.accept_compression_encodings; 5989 5989 + let send_compression_encodings = self.send_compression_encodings; 5990 5990 + let max_decoding_message_size = self.max_decoding_message_size; 5991 5991 + let max_encoding_message_size = self.max_encoding_message_size; 5992 5992 + let inner = self.inner.clone(); 5993 5993 + let fut = async move { 5994 5994 + let method = InsertTracksSvc(inner); 5995 5995 + let codec = tonic::codec::ProstCodec::default(); 5996 5996 + let mut grpc = tonic::server::Grpc::new(codec) 5997 5997 + .apply_compression_config( 5998 5998 + accept_compression_encodings, 5999 5999 + send_compression_encodings, 6000 6000 + ) 6001 6001 + .apply_max_message_size_config( 6002 6002 + max_decoding_message_size, 6003 6003 + max_encoding_message_size, 6004 6004 + ); 6005 6005 + let res = grpc.unary(method, req).await; 6006 6006 + Ok(res) 6007 6007 + }; 6008 6008 + Box::pin(fut) 6009 6009 + } 6010 6010 + "/rockbox.v1alpha1.PlaylistService/InsertDirectory" => { 6011 6011 + #[allow(non_camel_case_types)] 6012 6012 + struct InsertDirectorySvc<T: PlaylistService>(pub Arc<T>); 6013 6013 + impl< 6014 6014 + T: PlaylistService, 6015 6015 + > tonic::server::UnaryService<super::InsertDirectoryRequest> 6016 6016 + for InsertDirectorySvc<T> { 6017 6017 + type Response = super::InsertDirectoryResponse; 6018 6018 + type Future = BoxFuture< 6019 6019 + tonic::Response<Self::Response>, 6020 6020 + tonic::Status, 6021 6021 + >; 6022 6022 + fn call( 6023 6023 + &mut self, 6024 6024 + request: tonic::Request<super::InsertDirectoryRequest>, 6025 6025 + ) -> Self::Future { 6026 6026 + let inner = Arc::clone(&self.0); 6027 6027 + let fut = async move { 6028 6028 + <T as PlaylistService>::insert_directory(&inner, request) 6029 6029 + .await 6030 6030 + }; 6031 6031 + Box::pin(fut) 6032 6032 + } 6033 6033 + } 6034 6034 + let accept_compression_encodings = self.accept_compression_encodings; 6035 6035 + let send_compression_encodings = self.send_compression_encodings; 6036 6036 + let max_decoding_message_size = self.max_decoding_message_size; 6037 6037 + let max_encoding_message_size = self.max_encoding_message_size; 6038 6038 + let inner = self.inner.clone(); 6039 6039 + let fut = async move { 6040 6040 + let method = InsertDirectorySvc(inner); 6041 6041 + let codec = tonic::codec::ProstCodec::default(); 6042 6042 + let mut grpc = tonic::server::Grpc::new(codec) 6043 6043 + .apply_compression_config( 6044 6044 + accept_compression_encodings, 6045 6045 + send_compression_encodings, 6046 6046 + ) 6047 6047 + .apply_max_message_size_config( 6048 6048 + max_decoding_message_size, 6049 6049 + max_encoding_message_size, 6050 6050 + ); 6051 6051 + let res = grpc.unary(method, req).await; 6052 6052 + Ok(res) 6053 6053 + }; 6054 6054 + Box::pin(fut) 6055 6055 + } 6056 6056 + "/rockbox.v1alpha1.PlaylistService/InsertPlaylist" => { 6057 6057 + #[allow(non_camel_case_types)] 6058 6058 + struct InsertPlaylistSvc<T: PlaylistService>(pub Arc<T>); 6059 6059 + impl< 6060 6060 + T: PlaylistService, 6061 6061 + > tonic::server::UnaryService<super::InsertPlaylistRequest> 6062 6062 + for InsertPlaylistSvc<T> { 6063 6063 + type Response = super::InsertPlaylistResponse; 6064 6064 + type Future = BoxFuture< 6065 6065 + tonic::Response<Self::Response>, 6066 6066 + tonic::Status, 6067 6067 + >; 6068 6068 + fn call( 6069 6069 + &mut self, 6070 6070 + request: tonic::Request<super::InsertPlaylistRequest>, 6071 6071 + ) -> Self::Future { 6072 6072 + let inner = Arc::clone(&self.0); 6073 6073 + let fut = async move { 6074 6074 + <T as PlaylistService>::insert_playlist(&inner, request) 6075 6075 + .await 6076 6076 + }; 6077 6077 + Box::pin(fut) 6078 6078 + } 6079 6079 + } 6080 6080 + let accept_compression_encodings = self.accept_compression_encodings; 6081 6081 + let send_compression_encodings = self.send_compression_encodings; 6082 6082 + let max_decoding_message_size = self.max_decoding_message_size; 6083 6083 + let max_encoding_message_size = self.max_encoding_message_size; 6084 6084 + let inner = self.inner.clone(); 6085 6085 + let fut = async move { 6086 6086 + let method = InsertPlaylistSvc(inner); 6087 6087 + let codec = tonic::codec::ProstCodec::default(); 6088 6088 + let mut grpc = tonic::server::Grpc::new(codec) 6089 6089 + .apply_compression_config( 6090 6090 + accept_compression_encodings, 6091 6091 + send_compression_encodings, 6092 6092 + ) 6093 6093 + .apply_max_message_size_config( 6094 6094 + max_decoding_message_size, 6095 6095 + max_encoding_message_size, 6096 6096 + ); 6097 6097 + let res = grpc.unary(method, req).await; 6098 6098 + Ok(res) 6099 6099 + }; 6100 6100 + Box::pin(fut) 6101 6101 + } 6102 6102 + "/rockbox.v1alpha1.PlaylistService/InsertAlbum" => { 6103 6103 + #[allow(non_camel_case_types)] 6104 6104 + struct InsertAlbumSvc<T: PlaylistService>(pub Arc<T>); 6105 6105 + impl< 6106 6106 + T: PlaylistService, 6107 6107 + > tonic::server::UnaryService<super::InsertAlbumRequest> 6108 6108 + for InsertAlbumSvc<T> { 6109 6109 + type Response = super::InsertAlbumResponse; 6110 6110 + type Future = BoxFuture< 6111 6111 + tonic::Response<Self::Response>, 6112 6112 + tonic::Status, 6113 6113 + >; 6114 6114 + fn call( 6115 6115 + &mut self, 6116 6116 + request: tonic::Request<super::InsertAlbumRequest>, 6117 6117 + ) -> Self::Future { 6118 6118 + let inner = Arc::clone(&self.0); 6119 6119 + let fut = async move { 6120 6120 + <T as PlaylistService>::insert_album(&inner, request).await 6121 6121 + }; 6122 6122 + Box::pin(fut) 6123 6123 + } 6124 6124 + } 6125 6125 + let accept_compression_encodings = self.accept_compression_encodings; 6126 6126 + let send_compression_encodings = self.send_compression_encodings; 6127 6127 + let max_decoding_message_size = self.max_decoding_message_size; 6128 6128 + let max_encoding_message_size = self.max_encoding_message_size; 6129 6129 + let inner = self.inner.clone(); 6130 6130 + let fut = async move { 6131 6131 + let method = InsertAlbumSvc(inner); 6132 6132 + let codec = tonic::codec::ProstCodec::default(); 6133 6133 + let mut grpc = tonic::server::Grpc::new(codec) 6134 6134 + .apply_compression_config( 6135 6135 + accept_compression_encodings, 6136 6136 + send_compression_encodings, 6137 6137 + ) 6138 6138 + .apply_max_message_size_config( 6139 6139 + max_decoding_message_size, 6140 6140 + max_encoding_message_size, 6141 6141 + ); 6142 6142 + let res = grpc.unary(method, req).await; 6143 6143 + Ok(res) 6144 6144 + }; 6145 6145 + Box::pin(fut) 6146 6146 + } 6147 6147 + "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks" => { 6148 6148 + #[allow(non_camel_case_types)] 6149 6149 + struct InsertArtistTracksSvc<T: PlaylistService>(pub Arc<T>); 6150 6150 + impl< 6151 6151 + T: PlaylistService, 6152 6152 + > tonic::server::UnaryService<super::InsertArtistTracksRequest> 6153 6153 + for InsertArtistTracksSvc<T> { 6154 6154 + type Response = super::InsertArtistTracksResponse; 6155 6155 + type Future = BoxFuture< 6156 6156 + tonic::Response<Self::Response>, 6157 6157 + tonic::Status, 6158 6158 + >; 6159 6159 + fn call( 6160 6160 + &mut self, 6161 6161 + request: tonic::Request<super::InsertArtistTracksRequest>, 6162 6162 + ) -> Self::Future { 6163 6163 + let inner = Arc::clone(&self.0); 6164 6164 + let fut = async move { 6165 6165 + <T as PlaylistService>::insert_artist_tracks( 6166 6166 + &inner, 6167 6167 + request, 6168 6168 + ) 6169 6169 + .await 6170 6170 + }; 6171 6171 + Box::pin(fut) 6172 6172 + } 6173 6173 + } 6174 6174 + let accept_compression_encodings = self.accept_compression_encodings; 6175 6175 + let send_compression_encodings = self.send_compression_encodings; 6176 6176 + let max_decoding_message_size = self.max_decoding_message_size; 6177 6177 + let max_encoding_message_size = self.max_encoding_message_size; 6178 6178 + let inner = self.inner.clone(); 6179 6179 + let fut = async move { 6180 6180 + let method = InsertArtistTracksSvc(inner); 6181 6181 + let codec = tonic::codec::ProstCodec::default(); 6182 6182 + let mut grpc = tonic::server::Grpc::new(codec) 6183 6183 + .apply_compression_config( 6184 6184 + accept_compression_encodings, 6185 6185 + send_compression_encodings, 6186 6186 + ) 6187 6187 + .apply_max_message_size_config( 6188 6188 + max_decoding_message_size, 6189 6189 + max_encoding_message_size, 6190 6190 + ); 6191 6191 + let res = grpc.unary(method, req).await; 6192 6192 + Ok(res) 6193 6193 + }; 6194 6194 + Box::pin(fut) 6195 6195 + } 6196 6196 + "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist" => { 6197 6197 + #[allow(non_camel_case_types)] 6198 6198 + struct ShufflePlaylistSvc<T: PlaylistService>(pub Arc<T>); 6199 6199 + impl< 6200 6200 + T: PlaylistService, 6201 6201 + > tonic::server::UnaryService<super::ShufflePlaylistRequest> 6202 6202 + for ShufflePlaylistSvc<T> { 6203 6203 + type Response = super::ShufflePlaylistResponse; 6204 6204 + type Future = BoxFuture< 6205 6205 + tonic::Response<Self::Response>, 6206 6206 + tonic::Status, 6207 6207 + >; 6208 6208 + fn call( 6209 6209 + &mut self, 6210 6210 + request: tonic::Request<super::ShufflePlaylistRequest>, 6211 6211 + ) -> Self::Future { 6212 6212 + let inner = Arc::clone(&self.0); 6213 6213 + let fut = async move { 6214 6214 + <T as PlaylistService>::shuffle_playlist(&inner, request) 6215 6215 + .await 6216 6216 + }; 6217 6217 + Box::pin(fut) 6218 6218 + } 6219 6219 + } 6220 6220 + let accept_compression_encodings = self.accept_compression_encodings; 6221 6221 + let send_compression_encodings = self.send_compression_encodings; 6222 6222 + let max_decoding_message_size = self.max_decoding_message_size; 6223 6223 + let max_encoding_message_size = self.max_encoding_message_size; 6224 6224 + let inner = self.inner.clone(); 6225 6225 + let fut = async move { 6226 6226 + let method = ShufflePlaylistSvc(inner); 6227 6227 + let codec = tonic::codec::ProstCodec::default(); 6228 6228 + let mut grpc = tonic::server::Grpc::new(codec) 6229 6229 + .apply_compression_config( 6230 6230 + accept_compression_encodings, 6231 6231 + send_compression_encodings, 6232 6232 + ) 6233 6233 + .apply_max_message_size_config( 6234 6234 + max_decoding_message_size, 6235 6235 + max_encoding_message_size, 6236 6236 + ); 6237 6237 + let res = grpc.unary(method, req).await; 6238 6238 + Ok(res) 6239 6239 + }; 6240 6240 + Box::pin(fut) 6241 6241 + } 6242 6242 + _ => { 6243 6243 + Box::pin(async move { 6244 6244 + let mut response = http::Response::new(empty_body()); 6245 6245 + let headers = response.headers_mut(); 6246 6246 + headers 6247 6247 + .insert( 6248 6248 + tonic::Status::GRPC_STATUS, 6249 6249 + (tonic::Code::Unimplemented as i32).into(), 6250 6250 + ); 6251 6251 + headers 6252 6252 + .insert( 6253 6253 + http::header::CONTENT_TYPE, 6254 6254 + tonic::metadata::GRPC_CONTENT_TYPE, 6255 6255 + ); 6256 6256 + Ok(response) 6257 6257 + }) 6258 6258 + } 6259 6259 + } 6260 6260 + } 6261 6261 + } 6262 6262 + impl<T> Clone for PlaylistServiceServer<T> { 6263 6263 + fn clone(&self) -> Self { 6264 6264 + let inner = self.inner.clone(); 6265 6265 + Self { 6266 6266 + inner, 6267 6267 + accept_compression_encodings: self.accept_compression_encodings, 6268 6268 + send_compression_encodings: self.send_compression_encodings, 6269 6269 + max_decoding_message_size: self.max_decoding_message_size, 6270 6270 + max_encoding_message_size: self.max_encoding_message_size, 6271 6271 + } 6272 6272 + } 6273 6273 + } 6274 6274 + /// Generated gRPC service name 6275 6275 + pub const SERVICE_NAME: &str = "rockbox.v1alpha1.PlaylistService"; 6276 6276 + impl<T> tonic::server::NamedService for PlaylistServiceServer<T> { 6277 6277 + const NAME: &'static str = SERVICE_NAME; 6278 6278 + } 6279 6279 + } 6280 6280 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 6281 6281 + pub struct GetSettingsListRequest { 6282 6282 + #[prost(int32, tag = "1")] 6283 6283 + pub count: i32, 6284 6284 + } 6285 6285 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 6286 6286 + pub struct GetSettingsListResponse {} 6287 6287 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 6288 6288 + pub struct GetGlobalSettingsRequest {} 6289 6289 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 6290 6290 + pub struct ReplaygainSettings { 6291 6291 + #[prost(bool, tag = "1")] 6292 6292 + pub noclip: bool, 6293 6293 + #[prost(int32, tag = "2")] 6294 6294 + pub r#type: i32, 6295 6295 + #[prost(int32, tag = "3")] 6296 6296 + pub preamp: i32, 6297 6297 + } 6298 6298 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 6299 6299 + pub struct EqBandSetting { 6300 6300 + #[prost(int32, tag = "1")] 6301 6301 + pub cutoff: i32, 6302 6302 + #[prost(int32, tag = "2")] 6303 6303 + pub q: i32, 6304 6304 + #[prost(int32, tag = "3")] 6305 6305 + pub gain: i32, 6306 6306 + } 6307 6307 + #[derive(Clone, PartialEq, ::prost::Message)] 6308 6308 + pub struct SettingsList { 6309 6309 + #[prost(uint32, tag = "1")] 6310 6310 + pub flags: u32, 6311 6311 + #[prost(int32, tag = "2")] 6312 6312 + pub lang_id: i32, 6313 6313 + #[prost(string, tag = "3")] 6314 6314 + pub cfg_name: ::prost::alloc::string::String, 6315 6315 + #[prost(string, tag = "4")] 6316 6316 + pub cfg_vals: ::prost::alloc::string::String, 6317 6317 + } 6318 6318 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 6319 6319 + pub struct CompressorSettings { 6320 6320 + #[prost(int32, tag = "1")] 6321 6321 + pub threshold: i32, 6322 6322 + #[prost(int32, tag = "2")] 6323 6323 + pub makeup_gain: i32, 6324 6324 + #[prost(int32, tag = "3")] 6325 6325 + pub ratio: i32, 6326 6326 + #[prost(int32, tag = "4")] 6327 6327 + pub knee: i32, 6328 6328 + #[prost(int32, tag = "5")] 6329 6329 + pub release_time: i32, 6330 6330 + #[prost(int32, tag = "6")] 6331 6331 + pub attack_time: i32, 6332 6332 + } 6333 6333 + #[derive(Clone, PartialEq, ::prost::Message)] 6334 6334 + pub struct GetGlobalSettingsResponse { 6335 6335 + #[prost(int32, tag = "1")] 6336 6336 + pub volume: i32, 6337 6337 + #[prost(int32, tag = "2")] 6338 6338 + pub balance: i32, 6339 6339 + #[prost(int32, tag = "3")] 6340 6340 + pub bass: i32, 6341 6341 + #[prost(int32, tag = "4")] 6342 6342 + pub treble: i32, 6343 6343 + #[prost(int32, tag = "5")] 6344 6344 + pub channel_config: i32, 6345 6345 + #[prost(int32, tag = "6")] 6346 6346 + pub stereo_width: i32, 6347 6347 + #[prost(int32, tag = "7")] 6348 6348 + pub bass_cutoff: i32, 6349 6349 + #[prost(int32, tag = "8")] 6350 6350 + pub treble_cutoff: i32, 6351 6351 + #[prost(int32, tag = "9")] 6352 6352 + pub crossfade: i32, 6353 6353 + #[prost(int32, tag = "10")] 6354 6354 + pub crossfade_fade_in_delay: i32, 6355 6355 + #[prost(int32, tag = "11")] 6356 6356 + pub crossfade_fade_out_delay: i32, 6357 6357 + #[prost(int32, tag = "12")] 6358 6358 + pub crossfade_fade_in_duration: i32, 6359 6359 + #[prost(int32, tag = "13")] 6360 6360 + pub crossfade_fade_out_duration: i32, 6361 6361 + #[prost(int32, tag = "14")] 6362 6362 + pub crossfade_fade_out_mixmode: i32, 6363 6363 + #[prost(message, optional, tag = "15")] 6364 6364 + pub replaygain_settings: ::core::option::Option<ReplaygainSettings>, 6365 6365 + #[prost(int32, tag = "16")] 6366 6366 + pub crossfeed: i32, 6367 6367 + #[prost(uint32, tag = "17")] 6368 6368 + pub crossfeed_direct_gain: u32, 6369 6369 + #[prost(uint32, tag = "18")] 6370 6370 + pub crossfeed_cross_gain: u32, 6371 6371 + #[prost(uint32, tag = "19")] 6372 6372 + pub crossfeed_hf_attenuation: u32, 6373 6373 + #[prost(uint32, tag = "20")] 6374 6374 + pub crossfeed_hf_cutoff: u32, 6375 6375 + #[prost(bool, tag = "21")] 6376 6376 + pub eq_enabled: bool, 6377 6377 + #[prost(uint32, tag = "22")] 6378 6378 + pub eq_precut: u32, 6379 6379 + #[prost(message, repeated, tag = "23")] 6380 6380 + pub eq_band_settings: ::prost::alloc::vec::Vec<EqBandSetting>, 6381 6381 + #[prost(int32, tag = "24")] 6382 6382 + pub beep: i32, 6383 6383 + #[prost(int32, tag = "25")] 6384 6384 + pub keyclick: i32, 6385 6385 + #[prost(int32, tag = "26")] 6386 6386 + pub keyclick_repeats: i32, 6387 6387 + #[prost(bool, tag = "27")] 6388 6388 + pub dithering_enabled: bool, 6389 6389 + #[prost(bool, tag = "28")] 6390 6390 + pub timestretch_enabled: bool, 6391 6391 + #[prost(int32, tag = "29")] 6392 6392 + pub list_accel_start_delay: i32, 6393 6393 + #[prost(int32, tag = "30")] 6394 6394 + pub list_accel_wait: i32, 6395 6395 + #[prost(int32, tag = "31")] 6396 6396 + pub touchpad_sensitivity: i32, 6397 6397 + #[prost(int32, tag = "32")] 6398 6398 + pub touchpad_deadzone: i32, 6399 6399 + #[prost(int32, tag = "33")] 6400 6400 + pub pause_rewind: i32, 6401 6401 + #[prost(int32, tag = "34")] 6402 6402 + pub unplug_mode: i32, 6403 6403 + #[prost(bool, tag = "35")] 6404 6404 + pub unplug_autoresume: bool, 6405 6405 + #[prost(int32, tag = "37")] 6406 6406 + pub timeformat: i32, 6407 6407 + #[prost(int32, tag = "38")] 6408 6408 + pub disk_spindown: i32, 6409 6409 + #[prost(int32, tag = "39")] 6410 6410 + pub buffer_margin: i32, 6411 6411 + #[prost(int32, tag = "40")] 6412 6412 + pub dirfilter: i32, 6413 6413 + #[prost(int32, tag = "41")] 6414 6414 + pub show_filename_ext: i32, 6415 6415 + #[prost(int32, tag = "42")] 6416 6416 + pub default_codepage: i32, 6417 6417 + #[prost(bool, tag = "43")] 6418 6418 + pub hold_lr_for_scroll_in_list: bool, 6419 6419 + #[prost(bool, tag = "44")] 6420 6420 + pub play_selected: bool, 6421 6421 + #[prost(int32, tag = "45")] 6422 6422 + pub single_mode: i32, 6423 6423 + #[prost(bool, tag = "46")] 6424 6424 + pub party_mode: bool, 6425 6425 + #[prost(bool, tag = "48")] 6426 6426 + pub car_adapter_mode: bool, 6427 6427 + #[prost(int32, tag = "49")] 6428 6428 + pub car_adapter_mode_delay: i32, 6429 6429 + #[prost(int32, tag = "50")] 6430 6430 + pub start_in_screen: i32, 6431 6431 + #[prost(int32, tag = "51")] 6432 6432 + pub ff_rewind_min_step: i32, 6433 6433 + #[prost(int32, tag = "52")] 6434 6434 + pub ff_rewind_accel: i32, 6435 6435 + #[prost(int32, tag = "53")] 6436 6436 + pub peak_meter_release: i32, 6437 6437 + #[prost(int32, tag = "54")] 6438 6438 + pub peak_meter_hold: i32, 6439 6439 + #[prost(int32, tag = "55")] 6440 6440 + pub peak_meter_clip_hold: i32, 6441 6441 + #[prost(bool, tag = "56")] 6442 6442 + pub peak_meter_dbfs: bool, 6443 6443 + #[prost(int32, tag = "57")] 6444 6444 + pub peak_meter_min: i32, 6445 6445 + #[prost(int32, tag = "58")] 6446 6446 + pub peak_meter_max: i32, 6447 6447 + #[prost(string, tag = "59")] 6448 6448 + pub wps_file: ::prost::alloc::string::String, 6449 6449 + #[prost(string, tag = "60")] 6450 6450 + pub sbs_file: ::prost::alloc::string::String, 6451 6451 + #[prost(string, tag = "61")] 6452 6452 + pub lang_file: ::prost::alloc::string::String, 6453 6453 + #[prost(string, tag = "62")] 6454 6454 + pub playlist_catalog_dir: ::prost::alloc::string::String, 6455 6455 + #[prost(int32, tag = "63")] 6456 6456 + pub skip_length: i32, 6457 6457 + #[prost(int32, tag = "64")] 6458 6458 + pub max_files_in_dir: i32, 6459 6459 + #[prost(int32, tag = "65")] 6460 6460 + pub max_files_in_playlist: i32, 6461 6461 + #[prost(int32, tag = "66")] 6462 6462 + pub volume_type: i32, 6463 6463 + #[prost(int32, tag = "67")] 6464 6464 + pub battery_display: i32, 6465 6465 + #[prost(bool, tag = "68")] 6466 6466 + pub show_icons: bool, 6467 6467 + #[prost(int32, tag = "69")] 6468 6468 + pub statusbar: i32, 6469 6469 + #[prost(int32, tag = "70")] 6470 6470 + pub scrollbar: i32, 6471 6471 + #[prost(int32, tag = "71")] 6472 6472 + pub scrollbar_width: i32, 6473 6473 + #[prost(int32, tag = "72")] 6474 6474 + pub list_line_padding: i32, 6475 6475 + #[prost(int32, tag = "73")] 6476 6476 + pub list_separator_color: i32, 6477 6477 + #[prost(bool, tag = "74")] 6478 6478 + pub browse_current: bool, 6479 6479 + #[prost(bool, tag = "75")] 6480 6480 + pub scroll_paginated: bool, 6481 6481 + #[prost(bool, tag = "76")] 6482 6482 + pub list_wraparound: bool, 6483 6483 + #[prost(int32, tag = "77")] 6484 6484 + pub list_order: i32, 6485 6485 + #[prost(int32, tag = "78")] 6486 6486 + pub scroll_speed: i32, 6487 6487 + #[prost(int32, tag = "79")] 6488 6488 + pub bidir_limit: i32, 6489 6489 + #[prost(int32, tag = "80")] 6490 6490 + pub scroll_delay: i32, 6491 6491 + #[prost(int32, tag = "81")] 6492 6492 + pub scroll_step: i32, 6493 6493 + #[prost(int32, tag = "82")] 6494 6494 + pub autoloadbookmark: i32, 6495 6495 + #[prost(int32, tag = "83")] 6496 6496 + pub autocreatebookmark: i32, 6497 6497 + #[prost(bool, tag = "84")] 6498 6498 + pub autoupdatebookmark: bool, 6499 6499 + #[prost(int32, tag = "85")] 6500 6500 + pub usemrb: i32, 6501 6501 + #[prost(bool, tag = "86")] 6502 6502 + pub dircache: bool, 6503 6503 + #[prost(int32, tag = "87")] 6504 6504 + pub tagcache_ram: i32, 6505 6505 + #[prost(bool, tag = "88")] 6506 6506 + pub tagcache_autoupdate: bool, 6507 6507 + #[prost(bool, tag = "89")] 6508 6508 + pub autoresume_enable: bool, 6509 6509 + #[prost(int32, tag = "90")] 6510 6510 + pub autoresume_automatic: i32, 6511 6511 + #[prost(string, tag = "91")] 6512 6512 + pub autoresume_paths: ::prost::alloc::string::String, 6513 6513 + #[prost(bool, tag = "92")] 6514 6514 + pub runtimedb: bool, 6515 6515 + #[prost(string, tag = "93")] 6516 6516 + pub tagcache_scan_paths: ::prost::alloc::string::String, 6517 6517 + #[prost(string, tag = "94")] 6518 6518 + pub tagcache_db_path: ::prost::alloc::string::String, 6519 6519 + #[prost(string, tag = "95")] 6520 6520 + pub backdrop_file: ::prost::alloc::string::String, 6521 6521 + #[prost(int32, tag = "96")] 6522 6522 + pub bg_color: i32, 6523 6523 + #[prost(int32, tag = "97")] 6524 6524 + pub fg_color: i32, 6525 6525 + #[prost(int32, tag = "98")] 6526 6526 + pub lss_color: i32, 6527 6527 + #[prost(int32, tag = "99")] 6528 6528 + pub lse_color: i32, 6529 6529 + #[prost(int32, tag = "100")] 6530 6530 + pub lst_color: i32, 6531 6531 + #[prost(string, tag = "101")] 6532 6532 + pub colors_file: ::prost::alloc::string::String, 6533 6533 + #[prost(int32, tag = "102")] 6534 6534 + pub browser_default: i32, 6535 6535 + #[prost(int32, tag = "103")] 6536 6536 + pub repeat_mode: i32, 6537 6537 + #[prost(int32, tag = "104")] 6538 6538 + pub next_folder: i32, 6539 6539 + #[prost(bool, tag = "105")] 6540 6540 + pub constrain_next_folder: bool, 6541 6541 + #[prost(int32, tag = "106")] 6542 6542 + pub recursive_dir_insert: i32, 6543 6543 + #[prost(bool, tag = "107")] 6544 6544 + pub fade_on_stop: bool, 6545 6545 + #[prost(bool, tag = "108")] 6546 6546 + pub playlist_shuffle: bool, 6547 6547 + #[prost(bool, tag = "109")] 6548 6548 + pub warnon_erase_dynplaylist: bool, 6549 6549 + #[prost(bool, tag = "110")] 6550 6550 + pub keep_current_track_on_replace_playlist: bool, 6551 6551 + #[prost(bool, tag = "111")] 6552 6552 + pub show_shuffled_adding_options: bool, 6553 6553 + #[prost(int32, tag = "112")] 6554 6554 + pub show_queue_options: i32, 6555 6555 + #[prost(int32, tag = "113")] 6556 6556 + pub album_art: i32, 6557 6557 + #[prost(bool, tag = "114")] 6558 6558 + pub rewind_across_tracks: bool, 6559 6559 + #[prost(bool, tag = "115")] 6560 6560 + pub playlist_viewer_icons: bool, 6561 6561 + #[prost(bool, tag = "116")] 6562 6562 + pub playlist_viewer_indices: bool, 6563 6563 + #[prost(int32, tag = "117")] 6564 6564 + pub playlist_viewer_track_display: i32, 6565 6565 + #[prost(bool, tag = "118")] 6566 6566 + pub sort_case: bool, 6567 6567 + #[prost(int32, tag = "119")] 6568 6568 + pub sort_dir: i32, 6569 6569 + #[prost(int32, tag = "120")] 6570 6570 + pub sort_file: i32, 6571 6571 + #[prost(int32, tag = "121")] 6572 6572 + pub interpret_numbers: i32, 6573 6573 + #[prost(int32, tag = "122")] 6574 6574 + pub poweroff: i32, 6575 6575 + #[prost(bool, tag = "123")] 6576 6576 + pub spdif_enable: bool, 6577 6577 + #[prost(int32, tag = "124")] 6578 6578 + pub contrast: i32, 6579 6579 + #[prost(bool, tag = "125")] 6580 6580 + pub invert: bool, 6581 6581 + #[prost(bool, tag = "126")] 6582 6582 + pub flip_display: bool, 6583 6583 + #[prost(int32, tag = "127")] 6584 6584 + pub cursor_style: i32, 6585 6585 + #[prost(int32, tag = "128")] 6586 6586 + pub screen_scroll_step: i32, 6587 6587 + #[prost(int32, tag = "129")] 6588 6588 + pub show_path_in_browser: i32, 6589 6589 + #[prost(bool, tag = "130")] 6590 6590 + pub offset_out_of_view: bool, 6591 6591 + #[prost(bool, tag = "131")] 6592 6592 + pub disable_mainmenu_scrolling: bool, 6593 6593 + #[prost(string, tag = "132")] 6594 6594 + pub icon_file: ::prost::alloc::string::String, 6595 6595 + #[prost(string, tag = "133")] 6596 6596 + pub viewers_icon_file: ::prost::alloc::string::String, 6597 6597 + #[prost(string, tag = "134")] 6598 6598 + pub font_file: ::prost::alloc::string::String, 6599 6599 + #[prost(int32, tag = "135")] 6600 6600 + pub glyphs_to_cache: i32, 6601 6601 + #[prost(string, tag = "136")] 6602 6602 + pub kbd_file: ::prost::alloc::string::String, 6603 6603 + #[prost(int32, tag = "137")] 6604 6604 + pub backlight_timeout: i32, 6605 6605 + #[prost(bool, tag = "138")] 6606 6606 + pub caption_backlight: bool, 6607 6607 + #[prost(bool, tag = "139")] 6608 6608 + pub bl_filter_first_keypress: bool, 6609 6609 + #[prost(int32, tag = "140")] 6610 6610 + pub backlight_timeout_plugged: i32, 6611 6611 + #[prost(bool, tag = "141")] 6612 6612 + pub bt_selective_softlock_actions: bool, 6613 6613 + #[prost(int32, tag = "142")] 6614 6614 + pub bt_selective_softlock_actions_mask: i32, 6615 6615 + #[prost(bool, tag = "143")] 6616 6616 + pub bl_selective_actions: bool, 6617 6617 + #[prost(int32, tag = "144")] 6618 6618 + pub bl_selective_actions_mask: i32, 6619 6619 + #[prost(int32, tag = "145")] 6620 6620 + pub backlight_on_button_hold: i32, 6621 6621 + #[prost(int32, tag = "146")] 6622 6622 + pub lcd_sleep_after_backlight_off: i32, 6623 6623 + #[prost(int32, tag = "147")] 6624 6624 + pub brightness: i32, 6625 6625 + #[prost(int32, tag = "148")] 6626 6626 + pub speaker_mode: i32, 6627 6627 + #[prost(bool, tag = "149")] 6628 6628 + pub prevent_skip: bool, 6629 6629 + #[prost(int32, tag = "150")] 6630 6630 + pub touch_mode: i32, 6631 6631 + #[prost(bool, tag = "151")] 6632 6632 + pub pitch_mode_semitone: bool, 6633 6633 + #[prost(bool, tag = "152")] 6634 6634 + pub pitch_mode_timestretch: bool, 6635 6635 + #[prost(string, tag = "153")] 6636 6636 + pub player_name: ::prost::alloc::string::String, 6637 6637 + #[prost(message, optional, tag = "154")] 6638 6638 + pub compressor_settings: ::core::option::Option<CompressorSettings>, 6639 6639 + #[prost(int32, tag = "155")] 6640 6640 + pub sleeptimer_duration: i32, 6641 6641 + #[prost(bool, tag = "156")] 6642 6642 + pub sleeptimer_on_startup: bool, 6643 6643 + #[prost(bool, tag = "157")] 6644 6644 + pub keypress_restarts_sleeptimer: bool, 6645 6645 + #[prost(bool, tag = "158")] 6646 6646 + pub show_shutdown_message: bool, 6647 6647 + #[prost(int32, tag = "159")] 6648 6648 + pub hotkey_wps: i32, 6649 6649 + #[prost(int32, tag = "160")] 6650 6650 + pub hotkey_tree: i32, 6651 6651 + #[prost(int32, tag = "161")] 6652 6652 + pub resume_rewind: i32, 6653 6653 + #[prost(int32, tag = "162")] 6654 6654 + pub depth_3d: i32, 6655 6655 + #[prost(int32, tag = "163")] 6656 6656 + pub roll_off: i32, 6657 6657 + #[prost(int32, tag = "164")] 6658 6658 + pub power_mode: i32, 6659 6659 + #[prost(bool, tag = "165")] 6660 6660 + pub keyclick_hardware: bool, 6661 6661 + #[prost(string, tag = "166")] 6662 6662 + pub start_directory: ::prost::alloc::string::String, 6663 6663 + #[prost(bool, tag = "167")] 6664 6664 + pub root_menu_customized: bool, 6665 6665 + #[prost(bool, tag = "168")] 6666 6666 + pub shortcuts_replaces_qs: bool, 6667 6667 + #[prost(int32, tag = "169")] 6668 6668 + pub play_frequency: i32, 6669 6669 + #[prost(int32, tag = "170")] 6670 6670 + pub volume_limit: i32, 6671 6671 + #[prost(int32, tag = "171")] 6672 6672 + pub volume_adjust_mode: i32, 6673 6673 + #[prost(int32, tag = "172")] 6674 6674 + pub volume_adjust_norm_steps: i32, 6675 6675 + #[prost(int32, tag = "173")] 6676 6676 + pub surround_enabled: i32, 6677 6677 + #[prost(int32, tag = "174")] 6678 6678 + pub surround_balance: i32, 6679 6679 + #[prost(int32, tag = "175")] 6680 6680 + pub surround_fx1: i32, 6681 6681 + #[prost(int32, tag = "176")] 6682 6682 + pub surround_fx2: i32, 6683 6683 + #[prost(bool, tag = "177")] 6684 6684 + pub surround_method2: bool, 6685 6685 + #[prost(int32, tag = "178")] 6686 6686 + pub surround_mix: i32, 6687 6687 + #[prost(int32, tag = "179")] 6688 6688 + pub pbe: i32, 6689 6689 + #[prost(int32, tag = "180")] 6690 6690 + pub pbe_precut: i32, 6691 6691 + #[prost(int32, tag = "181")] 6692 6692 + pub afr_enabled: i32, 6693 6693 + #[prost(int32, tag = "182")] 6694 6694 + pub governor: i32, 6695 6695 + #[prost(int32, tag = "183")] 6696 6696 + pub stereosw_mode: i32, 6697 6697 + #[prost(string, tag = "184")] 6698 6698 + pub music_dir: ::prost::alloc::string::String, 6699 6699 + } 6700 6700 + #[derive(Clone, PartialEq, ::prost::Message)] 6701 6701 + pub struct SaveSettingsRequest { 6702 6702 + #[prost(string, optional, tag = "1")] 6703 6703 + pub music_dir: ::core::option::Option<::prost::alloc::string::String>, 6704 6704 + #[prost(bool, optional, tag = "2")] 6705 6705 + pub playlist_shuffle: ::core::option::Option<bool>, 6706 6706 + #[prost(int32, optional, tag = "3")] 6707 6707 + pub repeat_mode: ::core::option::Option<i32>, 6708 6708 + #[prost(int32, optional, tag = "4")] 6709 6709 + pub bass: ::core::option::Option<i32>, 6710 6710 + #[prost(int32, optional, tag = "5")] 6711 6711 + pub treble: ::core::option::Option<i32>, 6712 6712 + #[prost(int32, optional, tag = "6")] 6713 6713 + pub bass_cutoff: ::core::option::Option<i32>, 6714 6714 + #[prost(int32, optional, tag = "7")] 6715 6715 + pub treble_cutoff: ::core::option::Option<i32>, 6716 6716 + #[prost(int32, optional, tag = "8")] 6717 6717 + pub crossfade: ::core::option::Option<i32>, 6718 6718 + #[prost(bool, optional, tag = "9")] 6719 6719 + pub fade_on_stop: ::core::option::Option<bool>, 6720 6720 + #[prost(int32, optional, tag = "10")] 6721 6721 + pub fade_in_delay: ::core::option::Option<i32>, 6722 6722 + #[prost(int32, optional, tag = "11")] 6723 6723 + pub fade_in_duration: ::core::option::Option<i32>, 6724 6724 + #[prost(int32, optional, tag = "12")] 6725 6725 + pub fade_out_delay: ::core::option::Option<i32>, 6726 6726 + #[prost(int32, optional, tag = "13")] 6727 6727 + pub fade_out_duration: ::core::option::Option<i32>, 6728 6728 + #[prost(int32, optional, tag = "14")] 6729 6729 + pub fade_out_mixmode: ::core::option::Option<i32>, 6730 6730 + #[prost(int32, optional, tag = "15")] 6731 6731 + pub balance: ::core::option::Option<i32>, 6732 6732 + #[prost(int32, optional, tag = "16")] 6733 6733 + pub stereo_width: ::core::option::Option<i32>, 6734 6734 + #[prost(int32, optional, tag = "17")] 6735 6735 + pub stereosw_mode: ::core::option::Option<i32>, 6736 6736 + #[prost(int32, optional, tag = "18")] 6737 6737 + pub surround_enabled: ::core::option::Option<i32>, 6738 6738 + #[prost(int32, optional, tag = "19")] 6739 6739 + pub surround_balance: ::core::option::Option<i32>, 6740 6740 + #[prost(int32, optional, tag = "20")] 6741 6741 + pub surround_fx1: ::core::option::Option<i32>, 6742 6742 + #[prost(int32, optional, tag = "21")] 6743 6743 + pub surround_fx2: ::core::option::Option<i32>, 6744 6744 + #[prost(bool, optional, tag = "22")] 6745 6745 + pub party_mode: ::core::option::Option<bool>, 6746 6746 + #[prost(int32, optional, tag = "23")] 6747 6747 + pub channel_config: ::core::option::Option<i32>, 6748 6748 + #[prost(string, optional, tag = "24")] 6749 6749 + pub player_name: ::core::option::Option<::prost::alloc::string::String>, 6750 6750 + #[prost(bool, optional, tag = "25")] 6751 6751 + pub eq_enabled: ::core::option::Option<bool>, 6752 6752 + #[prost(message, repeated, tag = "26")] 6753 6753 + pub eq_band_settings: ::prost::alloc::vec::Vec<EqBandSetting>, 6754 6754 + #[prost(message, optional, tag = "27")] 6755 6755 + pub replaygain_settings: ::core::option::Option<ReplaygainSettings>, 6756 6756 + } 6757 6757 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 6758 6758 + pub struct SaveSettingsResponse {} 6759 6759 + /// Generated client implementations. 6760 6760 + pub mod settings_service_client { 6761 6761 + #![allow( 6762 6762 + unused_variables, 6763 6763 + dead_code, 6764 6764 + missing_docs, 6765 6765 + clippy::wildcard_imports, 6766 6766 + clippy::let_unit_value, 6767 6767 + )] 6768 6768 + use tonic::codegen::*; 6769 6769 + use tonic::codegen::http::Uri; 6770 6770 + #[derive(Debug, Clone)] 6771 6771 + pub struct SettingsServiceClient<T> { 6772 6772 + inner: tonic::client::Grpc<T>, 6773 6773 + } 6774 6774 + impl SettingsServiceClient<tonic::transport::Channel> { 6775 6775 + /// Attempt to create a new client by connecting to a given endpoint. 6776 6776 + pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error> 6777 6777 + where 6778 6778 + D: TryInto<tonic::transport::Endpoint>, 6779 6779 + D::Error: Into<StdError>, 6780 6780 + { 6781 6781 + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; 6782 6782 + Ok(Self::new(conn)) 6783 6783 + } 6784 6784 + } 6785 6785 + impl<T> SettingsServiceClient<T> 6786 6786 + where 6787 6787 + T: tonic::client::GrpcService<tonic::body::BoxBody>, 6788 6788 + T::Error: Into<StdError>, 6789 6789 + T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static, 6790 6790 + <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send, 6791 6791 + { 6792 6792 + pub fn new(inner: T) -> Self { 6793 6793 + let inner = tonic::client::Grpc::new(inner); 6794 6794 + Self { inner } 6795 6795 + } 6796 6796 + pub fn with_origin(inner: T, origin: Uri) -> Self { 6797 6797 + let inner = tonic::client::Grpc::with_origin(inner, origin); 6798 6798 + Self { inner } 6799 6799 + } 6800 6800 + pub fn with_interceptor<F>( 6801 6801 + inner: T, 6802 6802 + interceptor: F, 6803 6803 + ) -> SettingsServiceClient<InterceptedService<T, F>> 6804 6804 + where 6805 6805 + F: tonic::service::Interceptor, 6806 6806 + T::ResponseBody: Default, 6807 6807 + T: tonic::codegen::Service< 6808 6808 + http::Request<tonic::body::BoxBody>, 6809 6809 + Response = http::Response< 6810 6810 + <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 6811 6811 + >, 6812 6812 + >, 6813 6813 + <T as tonic::codegen::Service< 6814 6814 + http::Request<tonic::body::BoxBody>, 6815 6815 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6816 6816 + { 6817 6817 + SettingsServiceClient::new(InterceptedService::new(inner, interceptor)) 6818 6818 + } 6819 6819 + /// Compress requests with the given encoding. 6820 6820 + /// 6821 6821 + /// This requires the server to support it otherwise it might respond with an 6822 6822 + /// error. 6823 6823 + #[must_use] 6824 6824 + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { 6825 6825 + self.inner = self.inner.send_compressed(encoding); 6826 6826 + self 6827 6827 + } 6828 6828 + /// Enable decompressing responses. 6829 6829 + #[must_use] 6830 6830 + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { 6831 6831 + self.inner = self.inner.accept_compressed(encoding); 6832 6832 + self 6833 6833 + } 6834 6834 + /// Limits the maximum size of a decoded message. 6835 6835 + /// 6836 6836 + /// Default: `4MB` 6837 6837 + #[must_use] 6838 6838 + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { 6839 6839 + self.inner = self.inner.max_decoding_message_size(limit); 6840 6840 + self 6841 6841 + } 6842 6842 + /// Limits the maximum size of an encoded message. 6843 6843 + /// 6844 6844 + /// Default: `usize::MAX` 6845 6845 + #[must_use] 6846 6846 + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { 6847 6847 + self.inner = self.inner.max_encoding_message_size(limit); 6848 6848 + self 6849 6849 + } 6850 6850 + pub async fn get_settings_list( 6851 6851 + &mut self, 6852 6852 + request: impl tonic::IntoRequest<super::GetSettingsListRequest>, 6853 6853 + ) -> std::result::Result< 6854 6854 + tonic::Response<super::GetSettingsListResponse>, 6855 6855 + tonic::Status, 6856 6856 + > { 6857 6857 + self.inner 6858 6858 + .ready() 6859 6859 + .await 6860 6860 + .map_err(|e| { 6861 6861 + tonic::Status::unknown( 6862 6862 + format!("Service was not ready: {}", e.into()), 6863 6863 + ) 6864 6864 + })?; 6865 6865 + let codec = tonic::codec::ProstCodec::default(); 6866 6866 + let path = http::uri::PathAndQuery::from_static( 6867 6867 + "/rockbox.v1alpha1.SettingsService/GetSettingsList", 6868 6868 + ); 6869 6869 + let mut req = request.into_request(); 6870 6870 + req.extensions_mut() 6871 6871 + .insert( 6872 6872 + GrpcMethod::new( 6873 6873 + "rockbox.v1alpha1.SettingsService", 6874 6874 + "GetSettingsList", 6875 6875 + ), 6876 6876 + ); 6877 6877 + self.inner.unary(req, path, codec).await 6878 6878 + } 6879 6879 + pub async fn get_global_settings( 6880 6880 + &mut self, 6881 6881 + request: impl tonic::IntoRequest<super::GetGlobalSettingsRequest>, 6882 6882 + ) -> std::result::Result< 6883 6883 + tonic::Response<super::GetGlobalSettingsResponse>, 6884 6884 + tonic::Status, 6885 6885 + > { 6886 6886 + self.inner 6887 6887 + .ready() 6888 6888 + .await 6889 6889 + .map_err(|e| { 6890 6890 + tonic::Status::unknown( 6891 6891 + format!("Service was not ready: {}", e.into()), 6892 6892 + ) 6893 6893 + })?; 6894 6894 + let codec = tonic::codec::ProstCodec::default(); 6895 6895 + let path = http::uri::PathAndQuery::from_static( 6896 6896 + "/rockbox.v1alpha1.SettingsService/GetGlobalSettings", 6897 6897 + ); 6898 6898 + let mut req = request.into_request(); 6899 6899 + req.extensions_mut() 6900 6900 + .insert( 6901 6901 + GrpcMethod::new( 6902 6902 + "rockbox.v1alpha1.SettingsService", 6903 6903 + "GetGlobalSettings", 6904 6904 + ), 6905 6905 + ); 6906 6906 + self.inner.unary(req, path, codec).await 6907 6907 + } 6908 6908 + pub async fn save_settings( 6909 6909 + &mut self, 6910 6910 + request: impl tonic::IntoRequest<super::SaveSettingsRequest>, 6911 6911 + ) -> std::result::Result< 6912 6912 + tonic::Response<super::SaveSettingsResponse>, 6913 6913 + tonic::Status, 6914 6914 + > { 6915 6915 + self.inner 6916 6916 + .ready() 6917 6917 + .await 6918 6918 + .map_err(|e| { 6919 6919 + tonic::Status::unknown( 6920 6920 + format!("Service was not ready: {}", e.into()), 6921 6921 + ) 6922 6922 + })?; 6923 6923 + let codec = tonic::codec::ProstCodec::default(); 6924 6924 + let path = http::uri::PathAndQuery::from_static( 6925 6925 + "/rockbox.v1alpha1.SettingsService/SaveSettings", 6926 6926 + ); 6927 6927 + let mut req = request.into_request(); 6928 6928 + req.extensions_mut() 6929 6929 + .insert( 6930 6930 + GrpcMethod::new("rockbox.v1alpha1.SettingsService", "SaveSettings"), 6931 6931 + ); 6932 6932 + self.inner.unary(req, path, codec).await 6933 6933 + } 6934 6934 + } 6935 6935 + } 6936 6936 + /// Generated server implementations. 6937 6937 + pub mod settings_service_server { 6938 6938 + #![allow( 6939 6939 + unused_variables, 6940 6940 + dead_code, 6941 6941 + missing_docs, 6942 6942 + clippy::wildcard_imports, 6943 6943 + clippy::let_unit_value, 6944 6944 + )] 6945 6945 + use tonic::codegen::*; 6946 6946 + /// Generated trait containing gRPC methods that should be implemented for use with SettingsServiceServer. 6947 6947 + #[async_trait] 6948 6948 + pub trait SettingsService: std::marker::Send + std::marker::Sync + 'static { 6949 6949 + async fn get_settings_list( 6950 6950 + &self, 6951 6951 + request: tonic::Request<super::GetSettingsListRequest>, 6952 6952 + ) -> std::result::Result< 6953 6953 + tonic::Response<super::GetSettingsListResponse>, 6954 6954 + tonic::Status, 6955 6955 + >; 6956 6956 + async fn get_global_settings( 6957 6957 + &self, 6958 6958 + request: tonic::Request<super::GetGlobalSettingsRequest>, 6959 6959 + ) -> std::result::Result< 6960 6960 + tonic::Response<super::GetGlobalSettingsResponse>, 6961 6961 + tonic::Status, 6962 6962 + >; 6963 6963 + async fn save_settings( 6964 6964 + &self, 6965 6965 + request: tonic::Request<super::SaveSettingsRequest>, 6966 6966 + ) -> std::result::Result< 6967 6967 + tonic::Response<super::SaveSettingsResponse>, 6968 6968 + tonic::Status, 6969 6969 + >; 6970 6970 + } 6971 6971 + #[derive(Debug)] 6972 6972 + pub struct SettingsServiceServer<T> { 6973 6973 + inner: Arc<T>, 6974 6974 + accept_compression_encodings: EnabledCompressionEncodings, 6975 6975 + send_compression_encodings: EnabledCompressionEncodings, 6976 6976 + max_decoding_message_size: Option<usize>, 6977 6977 + max_encoding_message_size: Option<usize>, 6978 6978 + } 6979 6979 + impl<T> SettingsServiceServer<T> { 6980 6980 + pub fn new(inner: T) -> Self { 6981 6981 + Self::from_arc(Arc::new(inner)) 6982 6982 + } 6983 6983 + pub fn from_arc(inner: Arc<T>) -> Self { 6984 6984 + Self { 6985 6985 + inner, 6986 6986 + accept_compression_encodings: Default::default(), 6987 6987 + send_compression_encodings: Default::default(), 6988 6988 + max_decoding_message_size: None, 6989 6989 + max_encoding_message_size: None, 6990 6990 + } 6991 6991 + } 6992 6992 + pub fn with_interceptor<F>( 6993 6993 + inner: T, 6994 6994 + interceptor: F, 6995 6995 + ) -> InterceptedService<Self, F> 6996 6996 + where 6997 6997 + F: tonic::service::Interceptor, 6998 6998 + { 6999 6999 + InterceptedService::new(Self::new(inner), interceptor) 7000 7000 + } 7001 7001 + /// Enable decompressing requests with the given encoding. 7002 7002 + #[must_use] 7003 7003 + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { 7004 7004 + self.accept_compression_encodings.enable(encoding); 7005 7005 + self 7006 7006 + } 7007 7007 + /// Compress responses with the given encoding, if the client supports it. 7008 7008 + #[must_use] 7009 7009 + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { 7010 7010 + self.send_compression_encodings.enable(encoding); 7011 7011 + self 7012 7012 + } 7013 7013 + /// Limits the maximum size of a decoded message. 7014 7014 + /// 7015 7015 + /// Default: `4MB` 7016 7016 + #[must_use] 7017 7017 + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { 7018 7018 + self.max_decoding_message_size = Some(limit); 7019 7019 + self 7020 7020 + } 7021 7021 + /// Limits the maximum size of an encoded message. 7022 7022 + /// 7023 7023 + /// Default: `usize::MAX` 7024 7024 + #[must_use] 7025 7025 + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { 7026 7026 + self.max_encoding_message_size = Some(limit); 7027 7027 + self 7028 7028 + } 7029 7029 + } 7030 7030 + impl<T, B> tonic::codegen::Service<http::Request<B>> for SettingsServiceServer<T> 7031 7031 + where 7032 7032 + T: SettingsService, 7033 7033 + B: Body + std::marker::Send + 'static, 7034 7034 + B::Error: Into<StdError> + std::marker::Send + 'static, 7035 7035 + { 7036 7036 + type Response = http::Response<tonic::body::BoxBody>; 7037 7037 + type Error = std::convert::Infallible; 7038 7038 + type Future = BoxFuture<Self::Response, Self::Error>; 7039 7039 + fn poll_ready( 7040 7040 + &mut self, 7041 7041 + _cx: &mut Context<'_>, 7042 7042 + ) -> Poll<std::result::Result<(), Self::Error>> { 7043 7043 + Poll::Ready(Ok(())) 7044 7044 + } 7045 7045 + fn call(&mut self, req: http::Request<B>) -> Self::Future { 7046 7046 + match req.uri().path() { 7047 7047 + "/rockbox.v1alpha1.SettingsService/GetSettingsList" => { 7048 7048 + #[allow(non_camel_case_types)] 7049 7049 + struct GetSettingsListSvc<T: SettingsService>(pub Arc<T>); 7050 7050 + impl< 7051 7051 + T: SettingsService, 7052 7052 + > tonic::server::UnaryService<super::GetSettingsListRequest> 7053 7053 + for GetSettingsListSvc<T> { 7054 7054 + type Response = super::GetSettingsListResponse; 7055 7055 + type Future = BoxFuture< 7056 7056 + tonic::Response<Self::Response>, 7057 7057 + tonic::Status, 7058 7058 + >; 7059 7059 + fn call( 7060 7060 + &mut self, 7061 7061 + request: tonic::Request<super::GetSettingsListRequest>, 7062 7062 + ) -> Self::Future { 7063 7063 + let inner = Arc::clone(&self.0); 7064 7064 + let fut = async move { 7065 7065 + <T as SettingsService>::get_settings_list(&inner, request) 7066 7066 + .await 7067 7067 + }; 7068 7068 + Box::pin(fut) 7069 7069 + } 7070 7070 + } 7071 7071 + let accept_compression_encodings = self.accept_compression_encodings; 7072 7072 + let send_compression_encodings = self.send_compression_encodings; 7073 7073 + let max_decoding_message_size = self.max_decoding_message_size; 7074 7074 + let max_encoding_message_size = self.max_encoding_message_size; 7075 7075 + let inner = self.inner.clone(); 7076 7076 + let fut = async move { 7077 7077 + let method = GetSettingsListSvc(inner); 7078 7078 + let codec = tonic::codec::ProstCodec::default(); 7079 7079 + let mut grpc = tonic::server::Grpc::new(codec) 7080 7080 + .apply_compression_config( 7081 7081 + accept_compression_encodings, 7082 7082 + send_compression_encodings, 7083 7083 + ) 7084 7084 + .apply_max_message_size_config( 7085 7085 + max_decoding_message_size, 7086 7086 + max_encoding_message_size, 7087 7087 + ); 7088 7088 + let res = grpc.unary(method, req).await; 7089 7089 + Ok(res) 7090 7090 + }; 7091 7091 + Box::pin(fut) 7092 7092 + } 7093 7093 + "/rockbox.v1alpha1.SettingsService/GetGlobalSettings" => { 7094 7094 + #[allow(non_camel_case_types)] 7095 7095 + struct GetGlobalSettingsSvc<T: SettingsService>(pub Arc<T>); 7096 7096 + impl< 7097 7097 + T: SettingsService, 7098 7098 + > tonic::server::UnaryService<super::GetGlobalSettingsRequest> 7099 7099 + for GetGlobalSettingsSvc<T> { 7100 7100 + type Response = super::GetGlobalSettingsResponse; 7101 7101 + type Future = BoxFuture< 7102 7102 + tonic::Response<Self::Response>, 7103 7103 + tonic::Status, 7104 7104 + >; 7105 7105 + fn call( 7106 7106 + &mut self, 7107 7107 + request: tonic::Request<super::GetGlobalSettingsRequest>, 7108 7108 + ) -> Self::Future { 7109 7109 + let inner = Arc::clone(&self.0); 7110 7110 + let fut = async move { 7111 7111 + <T as SettingsService>::get_global_settings(&inner, request) 7112 7112 + .await 7113 7113 + }; 7114 7114 + Box::pin(fut) 7115 7115 + } 7116 7116 + } 7117 7117 + let accept_compression_encodings = self.accept_compression_encodings; 7118 7118 + let send_compression_encodings = self.send_compression_encodings; 7119 7119 + let max_decoding_message_size = self.max_decoding_message_size; 7120 7120 + let max_encoding_message_size = self.max_encoding_message_size; 7121 7121 + let inner = self.inner.clone(); 7122 7122 + let fut = async move { 7123 7123 + let method = GetGlobalSettingsSvc(inner); 7124 7124 + let codec = tonic::codec::ProstCodec::default(); 7125 7125 + let mut grpc = tonic::server::Grpc::new(codec) 7126 7126 + .apply_compression_config( 7127 7127 + accept_compression_encodings, 7128 7128 + send_compression_encodings, 7129 7129 + ) 7130 7130 + .apply_max_message_size_config( 7131 7131 + max_decoding_message_size, 7132 7132 + max_encoding_message_size, 7133 7133 + ); 7134 7134 + let res = grpc.unary(method, req).await; 7135 7135 + Ok(res) 7136 7136 + }; 7137 7137 + Box::pin(fut) 7138 7138 + } 7139 7139 + "/rockbox.v1alpha1.SettingsService/SaveSettings" => { 7140 7140 + #[allow(non_camel_case_types)] 7141 7141 + struct SaveSettingsSvc<T: SettingsService>(pub Arc<T>); 7142 7142 + impl< 7143 7143 + T: SettingsService, 7144 7144 + > tonic::server::UnaryService<super::SaveSettingsRequest> 7145 7145 + for SaveSettingsSvc<T> { 7146 7146 + type Response = super::SaveSettingsResponse; 7147 7147 + type Future = BoxFuture< 7148 7148 + tonic::Response<Self::Response>, 7149 7149 + tonic::Status, 7150 7150 + >; 7151 7151 + fn call( 7152 7152 + &mut self, 7153 7153 + request: tonic::Request<super::SaveSettingsRequest>, 7154 7154 + ) -> Self::Future { 7155 7155 + let inner = Arc::clone(&self.0); 7156 7156 + let fut = async move { 7157 7157 + <T as SettingsService>::save_settings(&inner, request).await 7158 7158 + }; 7159 7159 + Box::pin(fut) 7160 7160 + } 7161 7161 + } 7162 7162 + let accept_compression_encodings = self.accept_compression_encodings; 7163 7163 + let send_compression_encodings = self.send_compression_encodings; 7164 7164 + let max_decoding_message_size = self.max_decoding_message_size; 7165 7165 + let max_encoding_message_size = self.max_encoding_message_size; 7166 7166 + let inner = self.inner.clone(); 7167 7167 + let fut = async move { 7168 7168 + let method = SaveSettingsSvc(inner); 7169 7169 + let codec = tonic::codec::ProstCodec::default(); 7170 7170 + let mut grpc = tonic::server::Grpc::new(codec) 7171 7171 + .apply_compression_config( 7172 7172 + accept_compression_encodings, 7173 7173 + send_compression_encodings, 7174 7174 + ) 7175 7175 + .apply_max_message_size_config( 7176 7176 + max_decoding_message_size, 7177 7177 + max_encoding_message_size, 7178 7178 + ); 7179 7179 + let res = grpc.unary(method, req).await; 7180 7180 + Ok(res) 7181 7181 + }; 7182 7182 + Box::pin(fut) 7183 7183 + } 7184 7184 + _ => { 7185 7185 + Box::pin(async move { 7186 7186 + let mut response = http::Response::new(empty_body()); 7187 7187 + let headers = response.headers_mut(); 7188 7188 + headers 7189 7189 + .insert( 7190 7190 + tonic::Status::GRPC_STATUS, 7191 7191 + (tonic::Code::Unimplemented as i32).into(), 7192 7192 + ); 7193 7193 + headers 7194 7194 + .insert( 7195 7195 + http::header::CONTENT_TYPE, 7196 7196 + tonic::metadata::GRPC_CONTENT_TYPE, 7197 7197 + ); 7198 7198 + Ok(response) 7199 7199 + }) 7200 7200 + } 7201 7201 + } 7202 7202 + } 7203 7203 + } 7204 7204 + impl<T> Clone for SettingsServiceServer<T> { 7205 7205 + fn clone(&self) -> Self { 7206 7206 + let inner = self.inner.clone(); 7207 7207 + Self { 7208 7208 + inner, 7209 7209 + accept_compression_encodings: self.accept_compression_encodings, 7210 7210 + send_compression_encodings: self.send_compression_encodings, 7211 7211 + max_decoding_message_size: self.max_decoding_message_size, 7212 7212 + max_encoding_message_size: self.max_encoding_message_size, 7213 7213 + } 7214 7214 + } 7215 7215 + } 7216 7216 + /// Generated gRPC service name 7217 7217 + pub const SERVICE_NAME: &str = "rockbox.v1alpha1.SettingsService"; 7218 7218 + impl<T> tonic::server::NamedService for SettingsServiceServer<T> { 7219 7219 + const NAME: &'static str = SERVICE_NAME; 7220 7220 + } 7221 7221 + } 7222 7222 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7223 7223 + pub struct AdjustVolumeRequest { 7224 7224 + #[prost(int32, tag = "1")] 7225 7225 + pub steps: i32, 7226 7226 + } 7227 7227 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7228 7228 + pub struct AdjustVolumeResponse {} 7229 7229 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7230 7230 + pub struct SoundSetRequest { 7231 7231 + #[prost(int32, tag = "1")] 7232 7232 + pub setting: i32, 7233 7233 + #[prost(int32, tag = "2")] 7234 7234 + pub value: i32, 7235 7235 + } 7236 7236 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7237 7237 + pub struct SoundSetResponse {} 7238 7238 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7239 7239 + pub struct SoundCurrentRequest { 7240 7240 + #[prost(int32, tag = "1")] 7241 7241 + pub setting: i32, 7242 7242 + } 7243 7243 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7244 7244 + pub struct SoundCurrentResponse { 7245 7245 + #[prost(int32, tag = "1")] 7246 7246 + pub value: i32, 7247 7247 + } 7248 7248 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7249 7249 + pub struct SoundDefaultRequest { 7250 7250 + #[prost(int32, tag = "1")] 7251 7251 + pub setting: i32, 7252 7252 + } 7253 7253 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7254 7254 + pub struct SoundDefaultResponse { 7255 7255 + #[prost(int32, tag = "1")] 7256 7256 + pub value: i32, 7257 7257 + } 7258 7258 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7259 7259 + pub struct SoundMinRequest { 7260 7260 + #[prost(int32, tag = "1")] 7261 7261 + pub setting: i32, 7262 7262 + } 7263 7263 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7264 7264 + pub struct SoundMinResponse { 7265 7265 + #[prost(int32, tag = "1")] 7266 7266 + pub value: i32, 7267 7267 + } 7268 7268 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7269 7269 + pub struct SoundMaxRequest { 7270 7270 + #[prost(int32, tag = "1")] 7271 7271 + pub setting: i32, 7272 7272 + } 7273 7273 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7274 7274 + pub struct SoundMaxResponse { 7275 7275 + #[prost(int32, tag = "1")] 7276 7276 + pub value: i32, 7277 7277 + } 7278 7278 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7279 7279 + pub struct SoundUnitRequest {} 7280 7280 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7281 7281 + pub struct SoundUnitResponse {} 7282 7282 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7283 7283 + pub struct SoundVal2PhysRequest { 7284 7284 + #[prost(int32, tag = "1")] 7285 7285 + pub setting: i32, 7286 7286 + #[prost(int32, tag = "2")] 7287 7287 + pub value: i32, 7288 7288 + } 7289 7289 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7290 7290 + pub struct SoundVal2PhysResponse { 7291 7291 + #[prost(int32, tag = "1")] 7292 7292 + pub value: i32, 7293 7293 + } 7294 7294 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7295 7295 + pub struct GetPitchRequest {} 7296 7296 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7297 7297 + pub struct GetPitchResponse { 7298 7298 + #[prost(int32, tag = "1")] 7299 7299 + pub value: i32, 7300 7300 + } 7301 7301 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7302 7302 + pub struct SetPitchRequest { 7303 7303 + #[prost(int32, tag = "1")] 7304 7304 + pub value: i32, 7305 7305 + } 7306 7306 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7307 7307 + pub struct SetPitchResponse {} 7308 7308 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7309 7309 + pub struct BeepPlayRequest { 7310 7310 + #[prost(uint32, tag = "1")] 7311 7311 + pub frequency: u32, 7312 7312 + #[prost(uint32, tag = "2")] 7313 7313 + pub duration: u32, 7314 7314 + #[prost(uint32, tag = "3")] 7315 7315 + pub amplitude: u32, 7316 7316 + } 7317 7317 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7318 7318 + pub struct BeepPlayResponse {} 7319 7319 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7320 7320 + pub struct PcmbufFadeRequest { 7321 7321 + #[prost(int32, tag = "1")] 7322 7322 + pub fade: i32, 7323 7323 + #[prost(bool, tag = "2")] 7324 7324 + pub r#in: bool, 7325 7325 + } 7326 7326 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7327 7327 + pub struct PcmbufFadeResponse {} 7328 7328 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7329 7329 + pub struct PcmbufSetLowLatencyRequest { 7330 7330 + #[prost(bool, tag = "1")] 7331 7331 + pub state: bool, 7332 7332 + } 7333 7333 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7334 7334 + pub struct PcmbufSetLowLatencyResponse {} 7335 7335 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7336 7336 + pub struct SystemSoundPlayRequest { 7337 7337 + #[prost(uint32, tag = "1")] 7338 7338 + pub sound: u32, 7339 7339 + } 7340 7340 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7341 7341 + pub struct SystemSoundPlayResponse {} 7342 7342 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7343 7343 + pub struct KeyclickClickRequest { 7344 7344 + #[prost(bool, tag = "1")] 7345 7345 + pub rawbutton: bool, 7346 7346 + #[prost(int32, tag = "2")] 7347 7347 + pub action: i32, 7348 7348 + } 7349 7349 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 7350 7350 + pub struct KeyclickClickResponse {} 7351 7351 + /// Generated client implementations. 7352 7352 + pub mod sound_service_client { 7353 7353 + #![allow( 7354 7354 + unused_variables, 7355 7355 + dead_code, 7356 7356 + missing_docs, 7357 7357 + clippy::wildcard_imports, 7358 7358 + clippy::let_unit_value, 7359 7359 + )] 7360 7360 + use tonic::codegen::*; 7361 7361 + use tonic::codegen::http::Uri; 7362 7362 + #[derive(Debug, Clone)] 7363 7363 + pub struct SoundServiceClient<T> { 7364 7364 + inner: tonic::client::Grpc<T>, 7365 7365 + } 7366 7366 + impl SoundServiceClient<tonic::transport::Channel> { 7367 7367 + /// Attempt to create a new client by connecting to a given endpoint. 7368 7368 + pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error> 7369 7369 + where 7370 7370 + D: TryInto<tonic::transport::Endpoint>, 7371 7371 + D::Error: Into<StdError>, 7372 7372 + { 7373 7373 + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; 7374 7374 + Ok(Self::new(conn)) 7375 7375 + } 7376 7376 + } 7377 7377 + impl<T> SoundServiceClient<T> 7378 7378 + where 7379 7379 + T: tonic::client::GrpcService<tonic::body::BoxBody>, 7380 7380 + T::Error: Into<StdError>, 7381 7381 + T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static, 7382 7382 + <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send, 7383 7383 + { 7384 7384 + pub fn new(inner: T) -> Self { 7385 7385 + let inner = tonic::client::Grpc::new(inner); 7386 7386 + Self { inner } 7387 7387 + } 7388 7388 + pub fn with_origin(inner: T, origin: Uri) -> Self { 7389 7389 + let inner = tonic::client::Grpc::with_origin(inner, origin); 7390 7390 + Self { inner } 7391 7391 + } 7392 7392 + pub fn with_interceptor<F>( 7393 7393 + inner: T, 7394 7394 + interceptor: F, 7395 7395 + ) -> SoundServiceClient<InterceptedService<T, F>> 7396 7396 + where 7397 7397 + F: tonic::service::Interceptor, 7398 7398 + T::ResponseBody: Default, 7399 7399 + T: tonic::codegen::Service< 7400 7400 + http::Request<tonic::body::BoxBody>, 7401 7401 + Response = http::Response< 7402 7402 + <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 7403 7403 + >, 7404 7404 + >, 7405 7405 + <T as tonic::codegen::Service< 7406 7406 + http::Request<tonic::body::BoxBody>, 7407 7407 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 7408 7408 + { 7409 7409 + SoundServiceClient::new(InterceptedService::new(inner, interceptor)) 7410 7410 + } 7411 7411 + /// Compress requests with the given encoding. 7412 7412 + /// 7413 7413 + /// This requires the server to support it otherwise it might respond with an 7414 7414 + /// error. 7415 7415 + #[must_use] 7416 7416 + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { 7417 7417 + self.inner = self.inner.send_compressed(encoding); 7418 7418 + self 7419 7419 + } 7420 7420 + /// Enable decompressing responses. 7421 7421 + #[must_use] 7422 7422 + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { 7423 7423 + self.inner = self.inner.accept_compressed(encoding); 7424 7424 + self 7425 7425 + } 7426 7426 + /// Limits the maximum size of a decoded message. 7427 7427 + /// 7428 7428 + /// Default: `4MB` 7429 7429 + #[must_use] 7430 7430 + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { 7431 7431 + self.inner = self.inner.max_decoding_message_size(limit); 7432 7432 + self 7433 7433 + } 7434 7434 + /// Limits the maximum size of an encoded message. 7435 7435 + /// 7436 7436 + /// Default: `usize::MAX` 7437 7437 + #[must_use] 7438 7438 + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { 7439 7439 + self.inner = self.inner.max_encoding_message_size(limit); 7440 7440 + self 7441 7441 + } 7442 7442 + pub async fn adjust_volume( 7443 7443 + &mut self, 7444 7444 + request: impl tonic::IntoRequest<super::AdjustVolumeRequest>, 7445 7445 + ) -> std::result::Result< 7446 7446 + tonic::Response<super::AdjustVolumeResponse>, 7447 7447 + tonic::Status, 7448 7448 + > { 7449 7449 + self.inner 7450 7450 + .ready() 7451 7451 + .await 7452 7452 + .map_err(|e| { 7453 7453 + tonic::Status::unknown( 7454 7454 + format!("Service was not ready: {}", e.into()), 7455 7455 + ) 7456 7456 + })?; 7457 7457 + let codec = tonic::codec::ProstCodec::default(); 7458 7458 + let path = http::uri::PathAndQuery::from_static( 7459 7459 + "/rockbox.v1alpha1.SoundService/AdjustVolume", 7460 7460 + ); 7461 7461 + let mut req = request.into_request(); 7462 7462 + req.extensions_mut() 7463 7463 + .insert( 7464 7464 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "AdjustVolume"), 7465 7465 + ); 7466 7466 + self.inner.unary(req, path, codec).await 7467 7467 + } 7468 7468 + pub async fn sound_set( 7469 7469 + &mut self, 7470 7470 + request: impl tonic::IntoRequest<super::SoundSetRequest>, 7471 7471 + ) -> std::result::Result< 7472 7472 + tonic::Response<super::SoundSetResponse>, 7473 7473 + tonic::Status, 7474 7474 + > { 7475 7475 + self.inner 7476 7476 + .ready() 7477 7477 + .await 7478 7478 + .map_err(|e| { 7479 7479 + tonic::Status::unknown( 7480 7480 + format!("Service was not ready: {}", e.into()), 7481 7481 + ) 7482 7482 + })?; 7483 7483 + let codec = tonic::codec::ProstCodec::default(); 7484 7484 + let path = http::uri::PathAndQuery::from_static( 7485 7485 + "/rockbox.v1alpha1.SoundService/SoundSet", 7486 7486 + ); 7487 7487 + let mut req = request.into_request(); 7488 7488 + req.extensions_mut() 7489 7489 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundSet")); 7490 7490 + self.inner.unary(req, path, codec).await 7491 7491 + } 7492 7492 + pub async fn sound_current( 7493 7493 + &mut self, 7494 7494 + request: impl tonic::IntoRequest<super::SoundCurrentRequest>, 7495 7495 + ) -> std::result::Result< 7496 7496 + tonic::Response<super::SoundCurrentResponse>, 7497 7497 + tonic::Status, 7498 7498 + > { 7499 7499 + self.inner 7500 7500 + .ready() 7501 7501 + .await 7502 7502 + .map_err(|e| { 7503 7503 + tonic::Status::unknown( 7504 7504 + format!("Service was not ready: {}", e.into()), 7505 7505 + ) 7506 7506 + })?; 7507 7507 + let codec = tonic::codec::ProstCodec::default(); 7508 7508 + let path = http::uri::PathAndQuery::from_static( 7509 7509 + "/rockbox.v1alpha1.SoundService/SoundCurrent", 7510 7510 + ); 7511 7511 + let mut req = request.into_request(); 7512 7512 + req.extensions_mut() 7513 7513 + .insert( 7514 7514 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundCurrent"), 7515 7515 + ); 7516 7516 + self.inner.unary(req, path, codec).await 7517 7517 + } 7518 7518 + pub async fn sound_default( 7519 7519 + &mut self, 7520 7520 + request: impl tonic::IntoRequest<super::SoundDefaultRequest>, 7521 7521 + ) -> std::result::Result< 7522 7522 + tonic::Response<super::SoundDefaultResponse>, 7523 7523 + tonic::Status, 7524 7524 + > { 7525 7525 + self.inner 7526 7526 + .ready() 7527 7527 + .await 7528 7528 + .map_err(|e| { 7529 7529 + tonic::Status::unknown( 7530 7530 + format!("Service was not ready: {}", e.into()), 7531 7531 + ) 7532 7532 + })?; 7533 7533 + let codec = tonic::codec::ProstCodec::default(); 7534 7534 + let path = http::uri::PathAndQuery::from_static( 7535 7535 + "/rockbox.v1alpha1.SoundService/SoundDefault", 7536 7536 + ); 7537 7537 + let mut req = request.into_request(); 7538 7538 + req.extensions_mut() 7539 7539 + .insert( 7540 7540 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundDefault"), 7541 7541 + ); 7542 7542 + self.inner.unary(req, path, codec).await 7543 7543 + } 7544 7544 + pub async fn sound_min( 7545 7545 + &mut self, 7546 7546 + request: impl tonic::IntoRequest<super::SoundMinRequest>, 7547 7547 + ) -> std::result::Result< 7548 7548 + tonic::Response<super::SoundMinResponse>, 7549 7549 + tonic::Status, 7550 7550 + > { 7551 7551 + self.inner 7552 7552 + .ready() 7553 7553 + .await 7554 7554 + .map_err(|e| { 7555 7555 + tonic::Status::unknown( 7556 7556 + format!("Service was not ready: {}", e.into()), 7557 7557 + ) 7558 7558 + })?; 7559 7559 + let codec = tonic::codec::ProstCodec::default(); 7560 7560 + let path = http::uri::PathAndQuery::from_static( 7561 7561 + "/rockbox.v1alpha1.SoundService/SoundMin", 7562 7562 + ); 7563 7563 + let mut req = request.into_request(); 7564 7564 + req.extensions_mut() 7565 7565 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMin")); 7566 7566 + self.inner.unary(req, path, codec).await 7567 7567 + } 7568 7568 + pub async fn sound_max( 7569 7569 + &mut self, 7570 7570 + request: impl tonic::IntoRequest<super::SoundMaxRequest>, 7571 7571 + ) -> std::result::Result< 7572 7572 + tonic::Response<super::SoundMaxResponse>, 7573 7573 + tonic::Status, 7574 7574 + > { 7575 7575 + self.inner 7576 7576 + .ready() 7577 7577 + .await 7578 7578 + .map_err(|e| { 7579 7579 + tonic::Status::unknown( 7580 7580 + format!("Service was not ready: {}", e.into()), 7581 7581 + ) 7582 7582 + })?; 7583 7583 + let codec = tonic::codec::ProstCodec::default(); 7584 7584 + let path = http::uri::PathAndQuery::from_static( 7585 7585 + "/rockbox.v1alpha1.SoundService/SoundMax", 7586 7586 + ); 7587 7587 + let mut req = request.into_request(); 7588 7588 + req.extensions_mut() 7589 7589 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMax")); 7590 7590 + self.inner.unary(req, path, codec).await 7591 7591 + } 7592 7592 + pub async fn sound_unit( 7593 7593 + &mut self, 7594 7594 + request: impl tonic::IntoRequest<super::SoundUnitRequest>, 7595 7595 + ) -> std::result::Result< 7596 7596 + tonic::Response<super::SoundUnitResponse>, 7597 7597 + tonic::Status, 7598 7598 + > { 7599 7599 + self.inner 7600 7600 + .ready() 7601 7601 + .await 7602 7602 + .map_err(|e| { 7603 7603 + tonic::Status::unknown( 7604 7604 + format!("Service was not ready: {}", e.into()), 7605 7605 + ) 7606 7606 + })?; 7607 7607 + let codec = tonic::codec::ProstCodec::default(); 7608 7608 + let path = http::uri::PathAndQuery::from_static( 7609 7609 + "/rockbox.v1alpha1.SoundService/SoundUnit", 7610 7610 + ); 7611 7611 + let mut req = request.into_request(); 7612 7612 + req.extensions_mut() 7613 7613 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundUnit")); 7614 7614 + self.inner.unary(req, path, codec).await 7615 7615 + } 7616 7616 + pub async fn sound_val2_phys( 7617 7617 + &mut self, 7618 7618 + request: impl tonic::IntoRequest<super::SoundVal2PhysRequest>, 7619 7619 + ) -> std::result::Result< 7620 7620 + tonic::Response<super::SoundVal2PhysResponse>, 7621 7621 + tonic::Status, 7622 7622 + > { 7623 7623 + self.inner 7624 7624 + .ready() 7625 7625 + .await 7626 7626 + .map_err(|e| { 7627 7627 + tonic::Status::unknown( 7628 7628 + format!("Service was not ready: {}", e.into()), 7629 7629 + ) 7630 7630 + })?; 7631 7631 + let codec = tonic::codec::ProstCodec::default(); 7632 7632 + let path = http::uri::PathAndQuery::from_static( 7633 7633 + "/rockbox.v1alpha1.SoundService/SoundVal2Phys", 7634 7634 + ); 7635 7635 + let mut req = request.into_request(); 7636 7636 + req.extensions_mut() 7637 7637 + .insert( 7638 7638 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundVal2Phys"), 7639 7639 + ); 7640 7640 + self.inner.unary(req, path, codec).await 7641 7641 + } 7642 7642 + pub async fn get_pitch( 7643 7643 + &mut self, 7644 7644 + request: impl tonic::IntoRequest<super::GetPitchRequest>, 7645 7645 + ) -> std::result::Result< 7646 7646 + tonic::Response<super::GetPitchResponse>, 7647 7647 + tonic::Status, 7648 7648 + > { 7649 7649 + self.inner 7650 7650 + .ready() 7651 7651 + .await 7652 7652 + .map_err(|e| { 7653 7653 + tonic::Status::unknown( 7654 7654 + format!("Service was not ready: {}", e.into()), 7655 7655 + ) 7656 7656 + })?; 7657 7657 + let codec = tonic::codec::ProstCodec::default(); 7658 7658 + let path = http::uri::PathAndQuery::from_static( 7659 7659 + "/rockbox.v1alpha1.SoundService/GetPitch", 7660 7660 + ); 7661 7661 + let mut req = request.into_request(); 7662 7662 + req.extensions_mut() 7663 7663 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "GetPitch")); 7664 7664 + self.inner.unary(req, path, codec).await 7665 7665 + } 7666 7666 + pub async fn set_pitch( 7667 7667 + &mut self, 7668 7668 + request: impl tonic::IntoRequest<super::SetPitchRequest>, 7669 7669 + ) -> std::result::Result< 7670 7670 + tonic::Response<super::SetPitchResponse>, 7671 7671 + tonic::Status, 7672 7672 + > { 7673 7673 + self.inner 7674 7674 + .ready() 7675 7675 + .await 7676 7676 + .map_err(|e| { 7677 7677 + tonic::Status::unknown( 7678 7678 + format!("Service was not ready: {}", e.into()), 7679 7679 + ) 7680 7680 + })?; 7681 7681 + let codec = tonic::codec::ProstCodec::default(); 7682 7682 + let path = http::uri::PathAndQuery::from_static( 7683 7683 + "/rockbox.v1alpha1.SoundService/SetPitch", 7684 7684 + ); 7685 7685 + let mut req = request.into_request(); 7686 7686 + req.extensions_mut() 7687 7687 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SetPitch")); 7688 7688 + self.inner.unary(req, path, codec).await 7689 7689 + } 7690 7690 + pub async fn beep_play( 7691 7691 + &mut self, 7692 7692 + request: impl tonic::IntoRequest<super::BeepPlayRequest>, 7693 7693 + ) -> std::result::Result< 7694 7694 + tonic::Response<super::BeepPlayResponse>, 7695 7695 + tonic::Status, 7696 7696 + > { 7697 7697 + self.inner 7698 7698 + .ready() 7699 7699 + .await 7700 7700 + .map_err(|e| { 7701 7701 + tonic::Status::unknown( 7702 7702 + format!("Service was not ready: {}", e.into()), 7703 7703 + ) 7704 7704 + })?; 7705 7705 + let codec = tonic::codec::ProstCodec::default(); 7706 7706 + let path = http::uri::PathAndQuery::from_static( 7707 7707 + "/rockbox.v1alpha1.SoundService/BeepPlay", 7708 7708 + ); 7709 7709 + let mut req = request.into_request(); 7710 7710 + req.extensions_mut() 7711 7711 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "BeepPlay")); 7712 7712 + self.inner.unary(req, path, codec).await 7713 7713 + } 7714 7714 + pub async fn pcmbuf_fade( 7715 7715 + &mut self, 7716 7716 + request: impl tonic::IntoRequest<super::PcmbufFadeRequest>, 7717 7717 + ) -> std::result::Result< 7718 7718 + tonic::Response<super::PcmbufFadeResponse>, 7719 7719 + tonic::Status, 7720 7720 + > { 7721 7721 + self.inner 7722 7722 + .ready() 7723 7723 + .await 7724 7724 + .map_err(|e| { 7725 7725 + tonic::Status::unknown( 7726 7726 + format!("Service was not ready: {}", e.into()), 7727 7727 + ) 7728 7728 + })?; 7729 7729 + let codec = tonic::codec::ProstCodec::default(); 7730 7730 + let path = http::uri::PathAndQuery::from_static( 7731 7731 + "/rockbox.v1alpha1.SoundService/PcmbufFade", 7732 7732 + ); 7733 7733 + let mut req = request.into_request(); 7734 7734 + req.extensions_mut() 7735 7735 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "PcmbufFade")); 7736 7736 + self.inner.unary(req, path, codec).await 7737 7737 + } 7738 7738 + pub async fn pcmbuf_set_low_latency( 7739 7739 + &mut self, 7740 7740 + request: impl tonic::IntoRequest<super::PcmbufSetLowLatencyRequest>, 7741 7741 + ) -> std::result::Result< 7742 7742 + tonic::Response<super::PcmbufSetLowLatencyResponse>, 7743 7743 + tonic::Status, 7744 7744 + > { 7745 7745 + self.inner 7746 7746 + .ready() 7747 7747 + .await 7748 7748 + .map_err(|e| { 7749 7749 + tonic::Status::unknown( 7750 7750 + format!("Service was not ready: {}", e.into()), 7751 7751 + ) 7752 7752 + })?; 7753 7753 + let codec = tonic::codec::ProstCodec::default(); 7754 7754 + let path = http::uri::PathAndQuery::from_static( 7755 7755 + "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency", 7756 7756 + ); 7757 7757 + let mut req = request.into_request(); 7758 7758 + req.extensions_mut() 7759 7759 + .insert( 7760 7760 + GrpcMethod::new( 7761 7761 + "rockbox.v1alpha1.SoundService", 7762 7762 + "PcmbufSetLowLatency", 7763 7763 + ), 7764 7764 + ); 7765 7765 + self.inner.unary(req, path, codec).await 7766 7766 + } 7767 7767 + pub async fn system_sound_play( 7768 7768 + &mut self, 7769 7769 + request: impl tonic::IntoRequest<super::SystemSoundPlayRequest>, 7770 7770 + ) -> std::result::Result< 7771 7771 + tonic::Response<super::SystemSoundPlayResponse>, 7772 7772 + tonic::Status, 7773 7773 + > { 7774 7774 + self.inner 7775 7775 + .ready() 7776 7776 + .await 7777 7777 + .map_err(|e| { 7778 7778 + tonic::Status::unknown( 7779 7779 + format!("Service was not ready: {}", e.into()), 7780 7780 + ) 7781 7781 + })?; 7782 7782 + let codec = tonic::codec::ProstCodec::default(); 7783 7783 + let path = http::uri::PathAndQuery::from_static( 7784 7784 + "/rockbox.v1alpha1.SoundService/SystemSoundPlay", 7785 7785 + ); 7786 7786 + let mut req = request.into_request(); 7787 7787 + req.extensions_mut() 7788 7788 + .insert( 7789 7789 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SystemSoundPlay"), 7790 7790 + ); 7791 7791 + self.inner.unary(req, path, codec).await 7792 7792 + } 7793 7793 + pub async fn keyclick_click( 7794 7794 + &mut self, 7795 7795 + request: impl tonic::IntoRequest<super::KeyclickClickRequest>, 7796 7796 + ) -> std::result::Result< 7797 7797 + tonic::Response<super::KeyclickClickResponse>, 7798 7798 + tonic::Status, 7799 7799 + > { 7800 7800 + self.inner 7801 7801 + .ready() 7802 7802 + .await 7803 7803 + .map_err(|e| { 7804 7804 + tonic::Status::unknown( 7805 7805 + format!("Service was not ready: {}", e.into()), 7806 7806 + ) 7807 7807 + })?; 7808 7808 + let codec = tonic::codec::ProstCodec::default(); 7809 7809 + let path = http::uri::PathAndQuery::from_static( 7810 7810 + "/rockbox.v1alpha1.SoundService/KeyclickClick", 7811 7811 + ); 7812 7812 + let mut req = request.into_request(); 7813 7813 + req.extensions_mut() 7814 7814 + .insert( 7815 7815 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "KeyclickClick"), 7816 7816 + ); 7817 7817 + self.inner.unary(req, path, codec).await 7818 7818 + } 7819 7819 + } 7820 7820 + } 7821 7821 + /// Generated server implementations. 7822 7822 + pub mod sound_service_server { 7823 7823 + #![allow( 7824 7824 + unused_variables, 7825 7825 + dead_code, 7826 7826 + missing_docs, 7827 7827 + clippy::wildcard_imports, 7828 7828 + clippy::let_unit_value, 7829 7829 + )] 7830 7830 + use tonic::codegen::*; 7831 7831 + /// Generated trait containing gRPC methods that should be implemented for use with SoundServiceServer. 7832 7832 + #[async_trait] 7833 7833 + pub trait SoundService: std::marker::Send + std::marker::Sync + 'static { 7834 7834 + async fn adjust_volume( 7835 7835 + &self, 7836 7836 + request: tonic::Request<super::AdjustVolumeRequest>, 7837 7837 + ) -> std::result::Result< 7838 7838 + tonic::Response<super::AdjustVolumeResponse>, 7839 7839 + tonic::Status, 7840 7840 + >; 7841 7841 + async fn sound_set( 7842 7842 + &self, 7843 7843 + request: tonic::Request<super::SoundSetRequest>, 7844 7844 + ) -> std::result::Result< 7845 7845 + tonic::Response<super::SoundSetResponse>, 7846 7846 + tonic::Status, 7847 7847 + >; 7848 7848 + async fn sound_current( 7849 7849 + &self, 7850 7850 + request: tonic::Request<super::SoundCurrentRequest>, 7851 7851 + ) -> std::result::Result< 7852 7852 + tonic::Response<super::SoundCurrentResponse>, 7853 7853 + tonic::Status, 7854 7854 + >; 7855 7855 + async fn sound_default( 7856 7856 + &self, 7857 7857 + request: tonic::Request<super::SoundDefaultRequest>, 7858 7858 + ) -> std::result::Result< 7859 7859 + tonic::Response<super::SoundDefaultResponse>, 7860 7860 + tonic::Status, 7861 7861 + >; 7862 7862 + async fn sound_min( 7863 7863 + &self, 7864 7864 + request: tonic::Request<super::SoundMinRequest>, 7865 7865 + ) -> std::result::Result< 7866 7866 + tonic::Response<super::SoundMinResponse>, 7867 7867 + tonic::Status, 7868 7868 + >; 7869 7869 + async fn sound_max( 7870 7870 + &self, 7871 7871 + request: tonic::Request<super::SoundMaxRequest>, 7872 7872 + ) -> std::result::Result< 7873 7873 + tonic::Response<super::SoundMaxResponse>, 7874 7874 + tonic::Status, 7875 7875 + >; 7876 7876 + async fn sound_unit( 7877 7877 + &self, 7878 7878 + request: tonic::Request<super::SoundUnitRequest>, 7879 7879 + ) -> std::result::Result< 7880 7880 + tonic::Response<super::SoundUnitResponse>, 7881 7881 + tonic::Status, 7882 7882 + >; 7883 7883 + async fn sound_val2_phys( 7884 7884 + &self, 7885 7885 + request: tonic::Request<super::SoundVal2PhysRequest>, 7886 7886 + ) -> std::result::Result< 7887 7887 + tonic::Response<super::SoundVal2PhysResponse>, 7888 7888 + tonic::Status, 7889 7889 + >; 7890 7890 + async fn get_pitch( 7891 7891 + &self, 7892 7892 + request: tonic::Request<super::GetPitchRequest>, 7893 7893 + ) -> std::result::Result< 7894 7894 + tonic::Response<super::GetPitchResponse>, 7895 7895 + tonic::Status, 7896 7896 + >; 7897 7897 + async fn set_pitch( 7898 7898 + &self, 7899 7899 + request: tonic::Request<super::SetPitchRequest>, 7900 7900 + ) -> std::result::Result< 7901 7901 + tonic::Response<super::SetPitchResponse>, 7902 7902 + tonic::Status, 7903 7903 + >; 7904 7904 + async fn beep_play( 7905 7905 + &self, 7906 7906 + request: tonic::Request<super::BeepPlayRequest>, 7907 7907 + ) -> std::result::Result< 7908 7908 + tonic::Response<super::BeepPlayResponse>, 7909 7909 + tonic::Status, 7910 7910 + >; 7911 7911 + async fn pcmbuf_fade( 7912 7912 + &self, 7913 7913 + request: tonic::Request<super::PcmbufFadeRequest>, 7914 7914 + ) -> std::result::Result< 7915 7915 + tonic::Response<super::PcmbufFadeResponse>, 7916 7916 + tonic::Status, 7917 7917 + >; 7918 7918 + async fn pcmbuf_set_low_latency( 7919 7919 + &self, 7920 7920 + request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 7921 7921 + ) -> std::result::Result< 7922 7922 + tonic::Response<super::PcmbufSetLowLatencyResponse>, 7923 7923 + tonic::Status, 7924 7924 + >; 7925 7925 + async fn system_sound_play( 7926 7926 + &self, 7927 7927 + request: tonic::Request<super::SystemSoundPlayRequest>, 7928 7928 + ) -> std::result::Result< 7929 7929 + tonic::Response<super::SystemSoundPlayResponse>, 7930 7930 + tonic::Status, 7931 7931 + >; 7932 7932 + async fn keyclick_click( 7933 7933 + &self, 7934 7934 + request: tonic::Request<super::KeyclickClickRequest>, 7935 7935 + ) -> std::result::Result< 7936 7936 + tonic::Response<super::KeyclickClickResponse>, 7937 7937 + tonic::Status, 7938 7938 + >; 7939 7939 + } 7940 7940 + #[derive(Debug)] 7941 7941 + pub struct SoundServiceServer<T> { 7942 7942 + inner: Arc<T>, 7943 7943 + accept_compression_encodings: EnabledCompressionEncodings, 7944 7944 + send_compression_encodings: EnabledCompressionEncodings, 7945 7945 + max_decoding_message_size: Option<usize>, 7946 7946 + max_encoding_message_size: Option<usize>, 7947 7947 + } 7948 7948 + impl<T> SoundServiceServer<T> { 7949 7949 + pub fn new(inner: T) -> Self { 7950 7950 + Self::from_arc(Arc::new(inner)) 7951 7951 + } 7952 7952 + pub fn from_arc(inner: Arc<T>) -> Self { 7953 7953 + Self { 7954 7954 + inner, 7955 7955 + accept_compression_encodings: Default::default(), 7956 7956 + send_compression_encodings: Default::default(), 7957 7957 + max_decoding_message_size: None, 7958 7958 + max_encoding_message_size: None, 7959 7959 + } 7960 7960 + } 7961 7961 + pub fn with_interceptor<F>( 7962 7962 + inner: T, 7963 7963 + interceptor: F, 7964 7964 + ) -> InterceptedService<Self, F> 7965 7965 + where 7966 7966 + F: tonic::service::Interceptor, 7967 7967 + { 7968 7968 + InterceptedService::new(Self::new(inner), interceptor) 7969 7969 + } 7970 7970 + /// Enable decompressing requests with the given encoding. 7971 7971 + #[must_use] 7972 7972 + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { 7973 7973 + self.accept_compression_encodings.enable(encoding); 7974 7974 + self 7975 7975 + } 7976 7976 + /// Compress responses with the given encoding, if the client supports it. 7977 7977 + #[must_use] 7978 7978 + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { 7979 7979 + self.send_compression_encodings.enable(encoding); 7980 7980 + self 7981 7981 + } 7982 7982 + /// Limits the maximum size of a decoded message. 7983 7983 + /// 7984 7984 + /// Default: `4MB` 7985 7985 + #[must_use] 7986 7986 + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { 7987 7987 + self.max_decoding_message_size = Some(limit); 7988 7988 + self 7989 7989 + } 7990 7990 + /// Limits the maximum size of an encoded message. 7991 7991 + /// 7992 7992 + /// Default: `usize::MAX` 7993 7993 + #[must_use] 7994 7994 + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { 7995 7995 + self.max_encoding_message_size = Some(limit); 7996 7996 + self 7997 7997 + } 7998 7998 + } 7999 7999 + impl<T, B> tonic::codegen::Service<http::Request<B>> for SoundServiceServer<T> 8000 8000 + where 8001 8001 + T: SoundService, 8002 8002 + B: Body + std::marker::Send + 'static, 8003 8003 + B::Error: Into<StdError> + std::marker::Send + 'static, 8004 8004 + { 8005 8005 + type Response = http::Response<tonic::body::BoxBody>; 8006 8006 + type Error = std::convert::Infallible; 8007 8007 + type Future = BoxFuture<Self::Response, Self::Error>; 8008 8008 + fn poll_ready( 8009 8009 + &mut self, 8010 8010 + _cx: &mut Context<'_>, 8011 8011 + ) -> Poll<std::result::Result<(), Self::Error>> { 8012 8012 + Poll::Ready(Ok(())) 8013 8013 + } 8014 8014 + fn call(&mut self, req: http::Request<B>) -> Self::Future { 8015 8015 + match req.uri().path() { 8016 8016 + "/rockbox.v1alpha1.SoundService/AdjustVolume" => { 8017 8017 + #[allow(non_camel_case_types)] 8018 8018 + struct AdjustVolumeSvc<T: SoundService>(pub Arc<T>); 8019 8019 + impl< 8020 8020 + T: SoundService, 8021 8021 + > tonic::server::UnaryService<super::AdjustVolumeRequest> 8022 8022 + for AdjustVolumeSvc<T> { 8023 8023 + type Response = super::AdjustVolumeResponse; 8024 8024 + type Future = BoxFuture< 8025 8025 + tonic::Response<Self::Response>, 8026 8026 + tonic::Status, 8027 8027 + >; 8028 8028 + fn call( 8029 8029 + &mut self, 8030 8030 + request: tonic::Request<super::AdjustVolumeRequest>, 8031 8031 + ) -> Self::Future { 8032 8032 + let inner = Arc::clone(&self.0); 8033 8033 + let fut = async move { 8034 8034 + <T as SoundService>::adjust_volume(&inner, request).await 8035 8035 + }; 8036 8036 + Box::pin(fut) 8037 8037 + } 8038 8038 + } 8039 8039 + let accept_compression_encodings = self.accept_compression_encodings; 8040 8040 + let send_compression_encodings = self.send_compression_encodings; 8041 8041 + let max_decoding_message_size = self.max_decoding_message_size; 8042 8042 + let max_encoding_message_size = self.max_encoding_message_size; 8043 8043 + let inner = self.inner.clone(); 8044 8044 + let fut = async move { 8045 8045 + let method = AdjustVolumeSvc(inner); 8046 8046 + let codec = tonic::codec::ProstCodec::default(); 8047 8047 + let mut grpc = tonic::server::Grpc::new(codec) 8048 8048 + .apply_compression_config( 8049 8049 + accept_compression_encodings, 8050 8050 + send_compression_encodings, 8051 8051 + ) 8052 8052 + .apply_max_message_size_config( 8053 8053 + max_decoding_message_size, 8054 8054 + max_encoding_message_size, 8055 8055 + ); 8056 8056 + let res = grpc.unary(method, req).await; 8057 8057 + Ok(res) 8058 8058 + }; 8059 8059 + Box::pin(fut) 8060 8060 + } 8061 8061 + "/rockbox.v1alpha1.SoundService/SoundSet" => { 8062 8062 + #[allow(non_camel_case_types)] 8063 8063 + struct SoundSetSvc<T: SoundService>(pub Arc<T>); 8064 8064 + impl< 8065 8065 + T: SoundService, 8066 8066 + > tonic::server::UnaryService<super::SoundSetRequest> 8067 8067 + for SoundSetSvc<T> { 8068 8068 + type Response = super::SoundSetResponse; 8069 8069 + type Future = BoxFuture< 8070 8070 + tonic::Response<Self::Response>, 8071 8071 + tonic::Status, 8072 8072 + >; 8073 8073 + fn call( 8074 8074 + &mut self, 8075 8075 + request: tonic::Request<super::SoundSetRequest>, 8076 8076 + ) -> Self::Future { 8077 8077 + let inner = Arc::clone(&self.0); 8078 8078 + let fut = async move { 8079 8079 + <T as SoundService>::sound_set(&inner, request).await 8080 8080 + }; 8081 8081 + Box::pin(fut) 8082 8082 + } 8083 8083 + } 8084 8084 + let accept_compression_encodings = self.accept_compression_encodings; 8085 8085 + let send_compression_encodings = self.send_compression_encodings; 8086 8086 + let max_decoding_message_size = self.max_decoding_message_size; 8087 8087 + let max_encoding_message_size = self.max_encoding_message_size; 8088 8088 + let inner = self.inner.clone(); 8089 8089 + let fut = async move { 8090 8090 + let method = SoundSetSvc(inner); 8091 8091 + let codec = tonic::codec::ProstCodec::default(); 8092 8092 + let mut grpc = tonic::server::Grpc::new(codec) 8093 8093 + .apply_compression_config( 8094 8094 + accept_compression_encodings, 8095 8095 + send_compression_encodings, 8096 8096 + ) 8097 8097 + .apply_max_message_size_config( 8098 8098 + max_decoding_message_size, 8099 8099 + max_encoding_message_size, 8100 8100 + ); 8101 8101 + let res = grpc.unary(method, req).await; 8102 8102 + Ok(res) 8103 8103 + }; 8104 8104 + Box::pin(fut) 8105 8105 + } 8106 8106 + "/rockbox.v1alpha1.SoundService/SoundCurrent" => { 8107 8107 + #[allow(non_camel_case_types)] 8108 8108 + struct SoundCurrentSvc<T: SoundService>(pub Arc<T>); 8109 8109 + impl< 8110 8110 + T: SoundService, 8111 8111 + > tonic::server::UnaryService<super::SoundCurrentRequest> 8112 8112 + for SoundCurrentSvc<T> { 8113 8113 + type Response = super::SoundCurrentResponse; 8114 8114 + type Future = BoxFuture< 8115 8115 + tonic::Response<Self::Response>, 8116 8116 + tonic::Status, 8117 8117 + >; 8118 8118 + fn call( 8119 8119 + &mut self, 8120 8120 + request: tonic::Request<super::SoundCurrentRequest>, 8121 8121 + ) -> Self::Future { 8122 8122 + let inner = Arc::clone(&self.0); 8123 8123 + let fut = async move { 8124 8124 + <T as SoundService>::sound_current(&inner, request).await 8125 8125 + }; 8126 8126 + Box::pin(fut) 8127 8127 + } 8128 8128 + } 8129 8129 + let accept_compression_encodings = self.accept_compression_encodings; 8130 8130 + let send_compression_encodings = self.send_compression_encodings; 8131 8131 + let max_decoding_message_size = self.max_decoding_message_size; 8132 8132 + let max_encoding_message_size = self.max_encoding_message_size; 8133 8133 + let inner = self.inner.clone(); 8134 8134 + let fut = async move { 8135 8135 + let method = SoundCurrentSvc(inner); 8136 8136 + let codec = tonic::codec::ProstCodec::default(); 8137 8137 + let mut grpc = tonic::server::Grpc::new(codec) 8138 8138 + .apply_compression_config( 8139 8139 + accept_compression_encodings, 8140 8140 + send_compression_encodings, 8141 8141 + ) 8142 8142 + .apply_max_message_size_config( 8143 8143 + max_decoding_message_size, 8144 8144 + max_encoding_message_size, 8145 8145 + ); 8146 8146 + let res = grpc.unary(method, req).await; 8147 8147 + Ok(res) 8148 8148 + }; 8149 8149 + Box::pin(fut) 8150 8150 + } 8151 8151 + "/rockbox.v1alpha1.SoundService/SoundDefault" => { 8152 8152 + #[allow(non_camel_case_types)] 8153 8153 + struct SoundDefaultSvc<T: SoundService>(pub Arc<T>); 8154 8154 + impl< 8155 8155 + T: SoundService, 8156 8156 + > tonic::server::UnaryService<super::SoundDefaultRequest> 8157 8157 + for SoundDefaultSvc<T> { 8158 8158 + type Response = super::SoundDefaultResponse; 8159 8159 + type Future = BoxFuture< 8160 8160 + tonic::Response<Self::Response>, 8161 8161 + tonic::Status, 8162 8162 + >; 8163 8163 + fn call( 8164 8164 + &mut self, 8165 8165 + request: tonic::Request<super::SoundDefaultRequest>, 8166 8166 + ) -> Self::Future { 8167 8167 + let inner = Arc::clone(&self.0); 8168 8168 + let fut = async move { 8169 8169 + <T as SoundService>::sound_default(&inner, request).await 8170 8170 + }; 8171 8171 + Box::pin(fut) 8172 8172 + } 8173 8173 + } 8174 8174 + let accept_compression_encodings = self.accept_compression_encodings; 8175 8175 + let send_compression_encodings = self.send_compression_encodings; 8176 8176 + let max_decoding_message_size = self.max_decoding_message_size; 8177 8177 + let max_encoding_message_size = self.max_encoding_message_size; 8178 8178 + let inner = self.inner.clone(); 8179 8179 + let fut = async move { 8180 8180 + let method = SoundDefaultSvc(inner); 8181 8181 + let codec = tonic::codec::ProstCodec::default(); 8182 8182 + let mut grpc = tonic::server::Grpc::new(codec) 8183 8183 + .apply_compression_config( 8184 8184 + accept_compression_encodings, 8185 8185 + send_compression_encodings, 8186 8186 + ) 8187 8187 + .apply_max_message_size_config( 8188 8188 + max_decoding_message_size, 8189 8189 + max_encoding_message_size, 8190 8190 + ); 8191 8191 + let res = grpc.unary(method, req).await; 8192 8192 + Ok(res) 8193 8193 + }; 8194 8194 + Box::pin(fut) 8195 8195 + } 8196 8196 + "/rockbox.v1alpha1.SoundService/SoundMin" => { 8197 8197 + #[allow(non_camel_case_types)] 8198 8198 + struct SoundMinSvc<T: SoundService>(pub Arc<T>); 8199 8199 + impl< 8200 8200 + T: SoundService, 8201 8201 + > tonic::server::UnaryService<super::SoundMinRequest> 8202 8202 + for SoundMinSvc<T> { 8203 8203 + type Response = super::SoundMinResponse; 8204 8204 + type Future = BoxFuture< 8205 8205 + tonic::Response<Self::Response>, 8206 8206 + tonic::Status, 8207 8207 + >; 8208 8208 + fn call( 8209 8209 + &mut self, 8210 8210 + request: tonic::Request<super::SoundMinRequest>, 8211 8211 + ) -> Self::Future { 8212 8212 + let inner = Arc::clone(&self.0); 8213 8213 + let fut = async move { 8214 8214 + <T as SoundService>::sound_min(&inner, request).await 8215 8215 + }; 8216 8216 + Box::pin(fut) 8217 8217 + } 8218 8218 + } 8219 8219 + let accept_compression_encodings = self.accept_compression_encodings; 8220 8220 + let send_compression_encodings = self.send_compression_encodings; 8221 8221 + let max_decoding_message_size = self.max_decoding_message_size; 8222 8222 + let max_encoding_message_size = self.max_encoding_message_size; 8223 8223 + let inner = self.inner.clone(); 8224 8224 + let fut = async move { 8225 8225 + let method = SoundMinSvc(inner); 8226 8226 + let codec = tonic::codec::ProstCodec::default(); 8227 8227 + let mut grpc = tonic::server::Grpc::new(codec) 8228 8228 + .apply_compression_config( 8229 8229 + accept_compression_encodings, 8230 8230 + send_compression_encodings, 8231 8231 + ) 8232 8232 + .apply_max_message_size_config( 8233 8233 + max_decoding_message_size, 8234 8234 + max_encoding_message_size, 8235 8235 + ); 8236 8236 + let res = grpc.unary(method, req).await; 8237 8237 + Ok(res) 8238 8238 + }; 8239 8239 + Box::pin(fut) 8240 8240 + } 8241 8241 + "/rockbox.v1alpha1.SoundService/SoundMax" => { 8242 8242 + #[allow(non_camel_case_types)] 8243 8243 + struct SoundMaxSvc<T: SoundService>(pub Arc<T>); 8244 8244 + impl< 8245 8245 + T: SoundService, 8246 8246 + > tonic::server::UnaryService<super::SoundMaxRequest> 8247 8247 + for SoundMaxSvc<T> { 8248 8248 + type Response = super::SoundMaxResponse; 8249 8249 + type Future = BoxFuture< 8250 8250 + tonic::Response<Self::Response>, 8251 8251 + tonic::Status, 8252 8252 + >; 8253 8253 + fn call( 8254 8254 + &mut self, 8255 8255 + request: tonic::Request<super::SoundMaxRequest>, 8256 8256 + ) -> Self::Future { 8257 8257 + let inner = Arc::clone(&self.0); 8258 8258 + let fut = async move { 8259 8259 + <T as SoundService>::sound_max(&inner, request).await 8260 8260 + }; 8261 8261 + Box::pin(fut) 8262 8262 + } 8263 8263 + } 8264 8264 + let accept_compression_encodings = self.accept_compression_encodings; 8265 8265 + let send_compression_encodings = self.send_compression_encodings; 8266 8266 + let max_decoding_message_size = self.max_decoding_message_size; 8267 8267 + let max_encoding_message_size = self.max_encoding_message_size; 8268 8268 + let inner = self.inner.clone(); 8269 8269 + let fut = async move { 8270 8270 + let method = SoundMaxSvc(inner); 8271 8271 + let codec = tonic::codec::ProstCodec::default(); 8272 8272 + let mut grpc = tonic::server::Grpc::new(codec) 8273 8273 + .apply_compression_config( 8274 8274 + accept_compression_encodings, 8275 8275 + send_compression_encodings, 8276 8276 + ) 8277 8277 + .apply_max_message_size_config( 8278 8278 + max_decoding_message_size, 8279 8279 + max_encoding_message_size, 8280 8280 + ); 8281 8281 + let res = grpc.unary(method, req).await; 8282 8282 + Ok(res) 8283 8283 + }; 8284 8284 + Box::pin(fut) 8285 8285 + } 8286 8286 + "/rockbox.v1alpha1.SoundService/SoundUnit" => { 8287 8287 + #[allow(non_camel_case_types)] 8288 8288 + struct SoundUnitSvc<T: SoundService>(pub Arc<T>); 8289 8289 + impl< 8290 8290 + T: SoundService, 8291 8291 + > tonic::server::UnaryService<super::SoundUnitRequest> 8292 8292 + for SoundUnitSvc<T> { 8293 8293 + type Response = super::SoundUnitResponse; 8294 8294 + type Future = BoxFuture< 8295 8295 + tonic::Response<Self::Response>, 8296 8296 + tonic::Status, 8297 8297 + >; 8298 8298 + fn call( 8299 8299 + &mut self, 8300 8300 + request: tonic::Request<super::SoundUnitRequest>, 8301 8301 + ) -> Self::Future { 8302 8302 + let inner = Arc::clone(&self.0); 8303 8303 + let fut = async move { 8304 8304 + <T as SoundService>::sound_unit(&inner, request).await 8305 8305 + }; 8306 8306 + Box::pin(fut) 8307 8307 + } 8308 8308 + } 8309 8309 + let accept_compression_encodings = self.accept_compression_encodings; 8310 8310 + let send_compression_encodings = self.send_compression_encodings; 8311 8311 + let max_decoding_message_size = self.max_decoding_message_size; 8312 8312 + let max_encoding_message_size = self.max_encoding_message_size; 8313 8313 + let inner = self.inner.clone(); 8314 8314 + let fut = async move { 8315 8315 + let method = SoundUnitSvc(inner); 8316 8316 + let codec = tonic::codec::ProstCodec::default(); 8317 8317 + let mut grpc = tonic::server::Grpc::new(codec) 8318 8318 + .apply_compression_config( 8319 8319 + accept_compression_encodings, 8320 8320 + send_compression_encodings, 8321 8321 + ) 8322 8322 + .apply_max_message_size_config( 8323 8323 + max_decoding_message_size, 8324 8324 + max_encoding_message_size, 8325 8325 + ); 8326 8326 + let res = grpc.unary(method, req).await; 8327 8327 + Ok(res) 8328 8328 + }; 8329 8329 + Box::pin(fut) 8330 8330 + } 8331 8331 + "/rockbox.v1alpha1.SoundService/SoundVal2Phys" => { 8332 8332 + #[allow(non_camel_case_types)] 8333 8333 + struct SoundVal2PhysSvc<T: SoundService>(pub Arc<T>); 8334 8334 + impl< 8335 8335 + T: SoundService, 8336 8336 + > tonic::server::UnaryService<super::SoundVal2PhysRequest> 8337 8337 + for SoundVal2PhysSvc<T> { 8338 8338 + type Response = super::SoundVal2PhysResponse; 8339 8339 + type Future = BoxFuture< 8340 8340 + tonic::Response<Self::Response>, 8341 8341 + tonic::Status, 8342 8342 + >; 8343 8343 + fn call( 8344 8344 + &mut self, 8345 8345 + request: tonic::Request<super::SoundVal2PhysRequest>, 8346 8346 + ) -> Self::Future { 8347 8347 + let inner = Arc::clone(&self.0); 8348 8348 + let fut = async move { 8349 8349 + <T as SoundService>::sound_val2_phys(&inner, request).await 8350 8350 + }; 8351 8351 + Box::pin(fut) 8352 8352 + } 8353 8353 + } 8354 8354 + let accept_compression_encodings = self.accept_compression_encodings; 8355 8355 + let send_compression_encodings = self.send_compression_encodings; 8356 8356 + let max_decoding_message_size = self.max_decoding_message_size; 8357 8357 + let max_encoding_message_size = self.max_encoding_message_size; 8358 8358 + let inner = self.inner.clone(); 8359 8359 + let fut = async move { 8360 8360 + let method = SoundVal2PhysSvc(inner); 8361 8361 + let codec = tonic::codec::ProstCodec::default(); 8362 8362 + let mut grpc = tonic::server::Grpc::new(codec) 8363 8363 + .apply_compression_config( 8364 8364 + accept_compression_encodings, 8365 8365 + send_compression_encodings, 8366 8366 + ) 8367 8367 + .apply_max_message_size_config( 8368 8368 + max_decoding_message_size, 8369 8369 + max_encoding_message_size, 8370 8370 + ); 8371 8371 + let res = grpc.unary(method, req).await; 8372 8372 + Ok(res) 8373 8373 + }; 8374 8374 + Box::pin(fut) 8375 8375 + } 8376 8376 + "/rockbox.v1alpha1.SoundService/GetPitch" => { 8377 8377 + #[allow(non_camel_case_types)] 8378 8378 + struct GetPitchSvc<T: SoundService>(pub Arc<T>); 8379 8379 + impl< 8380 8380 + T: SoundService, 8381 8381 + > tonic::server::UnaryService<super::GetPitchRequest> 8382 8382 + for GetPitchSvc<T> { 8383 8383 + type Response = super::GetPitchResponse; 8384 8384 + type Future = BoxFuture< 8385 8385 + tonic::Response<Self::Response>, 8386 8386 + tonic::Status, 8387 8387 + >; 8388 8388 + fn call( 8389 8389 + &mut self, 8390 8390 + request: tonic::Request<super::GetPitchRequest>, 8391 8391 + ) -> Self::Future { 8392 8392 + let inner = Arc::clone(&self.0); 8393 8393 + let fut = async move { 8394 8394 + <T as SoundService>::get_pitch(&inner, request).await 8395 8395 + }; 8396 8396 + Box::pin(fut) 8397 8397 + } 8398 8398 + } 8399 8399 + let accept_compression_encodings = self.accept_compression_encodings; 8400 8400 + let send_compression_encodings = self.send_compression_encodings; 8401 8401 + let max_decoding_message_size = self.max_decoding_message_size; 8402 8402 + let max_encoding_message_size = self.max_encoding_message_size; 8403 8403 + let inner = self.inner.clone(); 8404 8404 + let fut = async move { 8405 8405 + let method = GetPitchSvc(inner); 8406 8406 + let codec = tonic::codec::ProstCodec::default(); 8407 8407 + let mut grpc = tonic::server::Grpc::new(codec) 8408 8408 + .apply_compression_config( 8409 8409 + accept_compression_encodings, 8410 8410 + send_compression_encodings, 8411 8411 + ) 8412 8412 + .apply_max_message_size_config( 8413 8413 + max_decoding_message_size, 8414 8414 + max_encoding_message_size, 8415 8415 + ); 8416 8416 + let res = grpc.unary(method, req).await; 8417 8417 + Ok(res) 8418 8418 + }; 8419 8419 + Box::pin(fut) 8420 8420 + } 8421 8421 + "/rockbox.v1alpha1.SoundService/SetPitch" => { 8422 8422 + #[allow(non_camel_case_types)] 8423 8423 + struct SetPitchSvc<T: SoundService>(pub Arc<T>); 8424 8424 + impl< 8425 8425 + T: SoundService, 8426 8426 + > tonic::server::UnaryService<super::SetPitchRequest> 8427 8427 + for SetPitchSvc<T> { 8428 8428 + type Response = super::SetPitchResponse; 8429 8429 + type Future = BoxFuture< 8430 8430 + tonic::Response<Self::Response>, 8431 8431 + tonic::Status, 8432 8432 + >; 8433 8433 + fn call( 8434 8434 + &mut self, 8435 8435 + request: tonic::Request<super::SetPitchRequest>, 8436 8436 + ) -> Self::Future { 8437 8437 + let inner = Arc::clone(&self.0); 8438 8438 + let fut = async move { 8439 8439 + <T as SoundService>::set_pitch(&inner, request).await 8440 8440 + }; 8441 8441 + Box::pin(fut) 8442 8442 + } 8443 8443 + } 8444 8444 + let accept_compression_encodings = self.accept_compression_encodings; 8445 8445 + let send_compression_encodings = self.send_compression_encodings; 8446 8446 + let max_decoding_message_size = self.max_decoding_message_size; 8447 8447 + let max_encoding_message_size = self.max_encoding_message_size; 8448 8448 + let inner = self.inner.clone(); 8449 8449 + let fut = async move { 8450 8450 + let method = SetPitchSvc(inner); 8451 8451 + let codec = tonic::codec::ProstCodec::default(); 8452 8452 + let mut grpc = tonic::server::Grpc::new(codec) 8453 8453 + .apply_compression_config( 8454 8454 + accept_compression_encodings, 8455 8455 + send_compression_encodings, 8456 8456 + ) 8457 8457 + .apply_max_message_size_config( 8458 8458 + max_decoding_message_size, 8459 8459 + max_encoding_message_size, 8460 8460 + ); 8461 8461 + let res = grpc.unary(method, req).await; 8462 8462 + Ok(res) 8463 8463 + }; 8464 8464 + Box::pin(fut) 8465 8465 + } 8466 8466 + "/rockbox.v1alpha1.SoundService/BeepPlay" => { 8467 8467 + #[allow(non_camel_case_types)] 8468 8468 + struct BeepPlaySvc<T: SoundService>(pub Arc<T>); 8469 8469 + impl< 8470 8470 + T: SoundService, 8471 8471 + > tonic::server::UnaryService<super::BeepPlayRequest> 8472 8472 + for BeepPlaySvc<T> { 8473 8473 + type Response = super::BeepPlayResponse; 8474 8474 + type Future = BoxFuture< 8475 8475 + tonic::Response<Self::Response>, 8476 8476 + tonic::Status, 8477 8477 + >; 8478 8478 + fn call( 8479 8479 + &mut self, 8480 8480 + request: tonic::Request<super::BeepPlayRequest>, 8481 8481 + ) -> Self::Future { 8482 8482 + let inner = Arc::clone(&self.0); 8483 8483 + let fut = async move { 8484 8484 + <T as SoundService>::beep_play(&inner, request).await 8485 8485 + }; 8486 8486 + Box::pin(fut) 8487 8487 + } 8488 8488 + } 8489 8489 + let accept_compression_encodings = self.accept_compression_encodings; 8490 8490 + let send_compression_encodings = self.send_compression_encodings; 8491 8491 + let max_decoding_message_size = self.max_decoding_message_size; 8492 8492 + let max_encoding_message_size = self.max_encoding_message_size; 8493 8493 + let inner = self.inner.clone(); 8494 8494 + let fut = async move { 8495 8495 + let method = BeepPlaySvc(inner); 8496 8496 + let codec = tonic::codec::ProstCodec::default(); 8497 8497 + let mut grpc = tonic::server::Grpc::new(codec) 8498 8498 + .apply_compression_config( 8499 8499 + accept_compression_encodings, 8500 8500 + send_compression_encodings, 8501 8501 + ) 8502 8502 + .apply_max_message_size_config( 8503 8503 + max_decoding_message_size, 8504 8504 + max_encoding_message_size, 8505 8505 + ); 8506 8506 + let res = grpc.unary(method, req).await; 8507 8507 + Ok(res) 8508 8508 + }; 8509 8509 + Box::pin(fut) 8510 8510 + } 8511 8511 + "/rockbox.v1alpha1.SoundService/PcmbufFade" => { 8512 8512 + #[allow(non_camel_case_types)] 8513 8513 + struct PcmbufFadeSvc<T: SoundService>(pub Arc<T>); 8514 8514 + impl< 8515 8515 + T: SoundService, 8516 8516 + > tonic::server::UnaryService<super::PcmbufFadeRequest> 8517 8517 + for PcmbufFadeSvc<T> { 8518 8518 + type Response = super::PcmbufFadeResponse; 8519 8519 + type Future = BoxFuture< 8520 8520 + tonic::Response<Self::Response>, 8521 8521 + tonic::Status, 8522 8522 + >; 8523 8523 + fn call( 8524 8524 + &mut self, 8525 8525 + request: tonic::Request<super::PcmbufFadeRequest>, 8526 8526 + ) -> Self::Future { 8527 8527 + let inner = Arc::clone(&self.0); 8528 8528 + let fut = async move { 8529 8529 + <T as SoundService>::pcmbuf_fade(&inner, request).await 8530 8530 + }; 8531 8531 + Box::pin(fut) 8532 8532 + } 8533 8533 + } 8534 8534 + let accept_compression_encodings = self.accept_compression_encodings; 8535 8535 + let send_compression_encodings = self.send_compression_encodings; 8536 8536 + let max_decoding_message_size = self.max_decoding_message_size; 8537 8537 + let max_encoding_message_size = self.max_encoding_message_size; 8538 8538 + let inner = self.inner.clone(); 8539 8539 + let fut = async move { 8540 8540 + let method = PcmbufFadeSvc(inner); 8541 8541 + let codec = tonic::codec::ProstCodec::default(); 8542 8542 + let mut grpc = tonic::server::Grpc::new(codec) 8543 8543 + .apply_compression_config( 8544 8544 + accept_compression_encodings, 8545 8545 + send_compression_encodings, 8546 8546 + ) 8547 8547 + .apply_max_message_size_config( 8548 8548 + max_decoding_message_size, 8549 8549 + max_encoding_message_size, 8550 8550 + ); 8551 8551 + let res = grpc.unary(method, req).await; 8552 8552 + Ok(res) 8553 8553 + }; 8554 8554 + Box::pin(fut) 8555 8555 + } 8556 8556 + "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency" => { 8557 8557 + #[allow(non_camel_case_types)] 8558 8558 + struct PcmbufSetLowLatencySvc<T: SoundService>(pub Arc<T>); 8559 8559 + impl< 8560 8560 + T: SoundService, 8561 8561 + > tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 8562 8562 + for PcmbufSetLowLatencySvc<T> { 8563 8563 + type Response = super::PcmbufSetLowLatencyResponse; 8564 8564 + type Future = BoxFuture< 8565 8565 + tonic::Response<Self::Response>, 8566 8566 + tonic::Status, 8567 8567 + >; 8568 8568 + fn call( 8569 8569 + &mut self, 8570 8570 + request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 8571 8571 + ) -> Self::Future { 8572 8572 + let inner = Arc::clone(&self.0); 8573 8573 + let fut = async move { 8574 8574 + <T as SoundService>::pcmbuf_set_low_latency(&inner, request) 8575 8575 + .await 8576 8576 + }; 8577 8577 + Box::pin(fut) 8578 8578 + } 8579 8579 + } 8580 8580 + let accept_compression_encodings = self.accept_compression_encodings; 8581 8581 + let send_compression_encodings = self.send_compression_encodings; 8582 8582 + let max_decoding_message_size = self.max_decoding_message_size; 8583 8583 + let max_encoding_message_size = self.max_encoding_message_size; 8584 8584 + let inner = self.inner.clone(); 8585 8585 + let fut = async move { 8586 8586 + let method = PcmbufSetLowLatencySvc(inner); 8587 8587 + let codec = tonic::codec::ProstCodec::default(); 8588 8588 + let mut grpc = tonic::server::Grpc::new(codec) 8589 8589 + .apply_compression_config( 8590 8590 + accept_compression_encodings, 8591 8591 + send_compression_encodings, 8592 8592 + ) 8593 8593 + .apply_max_message_size_config( 8594 8594 + max_decoding_message_size, 8595 8595 + max_encoding_message_size, 8596 8596 + ); 8597 8597 + let res = grpc.unary(method, req).await; 8598 8598 + Ok(res) 8599 8599 + }; 8600 8600 + Box::pin(fut) 8601 8601 + } 8602 8602 + "/rockbox.v1alpha1.SoundService/SystemSoundPlay" => { 8603 8603 + #[allow(non_camel_case_types)] 8604 8604 + struct SystemSoundPlaySvc<T: SoundService>(pub Arc<T>); 8605 8605 + impl< 8606 8606 + T: SoundService, 8607 8607 + > tonic::server::UnaryService<super::SystemSoundPlayRequest> 8608 8608 + for SystemSoundPlaySvc<T> { 8609 8609 + type Response = super::SystemSoundPlayResponse; 8610 8610 + type Future = BoxFuture< 8611 8611 + tonic::Response<Self::Response>, 8612 8612 + tonic::Status, 8613 8613 + >; 8614 8614 + fn call( 8615 8615 + &mut self, 8616 8616 + request: tonic::Request<super::SystemSoundPlayRequest>, 8617 8617 + ) -> Self::Future { 8618 8618 + let inner = Arc::clone(&self.0); 8619 8619 + let fut = async move { 8620 8620 + <T as SoundService>::system_sound_play(&inner, request) 8621 8621 + .await 8622 8622 + }; 8623 8623 + Box::pin(fut) 8624 8624 + } 8625 8625 + } 8626 8626 + let accept_compression_encodings = self.accept_compression_encodings; 8627 8627 + let send_compression_encodings = self.send_compression_encodings; 8628 8628 + let max_decoding_message_size = self.max_decoding_message_size; 8629 8629 + let max_encoding_message_size = self.max_encoding_message_size; 8630 8630 + let inner = self.inner.clone(); 8631 8631 + let fut = async move { 8632 8632 + let method = SystemSoundPlaySvc(inner); 8633 8633 + let codec = tonic::codec::ProstCodec::default(); 8634 8634 + let mut grpc = tonic::server::Grpc::new(codec) 8635 8635 + .apply_compression_config( 8636 8636 + accept_compression_encodings, 8637 8637 + send_compression_encodings, 8638 8638 + ) 8639 8639 + .apply_max_message_size_config( 8640 8640 + max_decoding_message_size, 8641 8641 + max_encoding_message_size, 8642 8642 + ); 8643 8643 + let res = grpc.unary(method, req).await; 8644 8644 + Ok(res) 8645 8645 + }; 8646 8646 + Box::pin(fut) 8647 8647 + } 8648 8648 + "/rockbox.v1alpha1.SoundService/KeyclickClick" => { 8649 8649 + #[allow(non_camel_case_types)] 8650 8650 + struct KeyclickClickSvc<T: SoundService>(pub Arc<T>); 8651 8651 + impl< 8652 8652 + T: SoundService, 8653 8653 + > tonic::server::UnaryService<super::KeyclickClickRequest> 8654 8654 + for KeyclickClickSvc<T> { 8655 8655 + type Response = super::KeyclickClickResponse; 8656 8656 + type Future = BoxFuture< 8657 8657 + tonic::Response<Self::Response>, 8658 8658 + tonic::Status, 8659 8659 + >; 8660 8660 + fn call( 8661 8661 + &mut self, 8662 8662 + request: tonic::Request<super::KeyclickClickRequest>, 8663 8663 + ) -> Self::Future { 8664 8664 + let inner = Arc::clone(&self.0); 8665 8665 + let fut = async move { 8666 8666 + <T as SoundService>::keyclick_click(&inner, request).await 8667 8667 + }; 8668 8668 + Box::pin(fut) 8669 8669 + } 8670 8670 + } 8671 8671 + let accept_compression_encodings = self.accept_compression_encodings; 8672 8672 + let send_compression_encodings = self.send_compression_encodings; 8673 8673 + let max_decoding_message_size = self.max_decoding_message_size; 8674 8674 + let max_encoding_message_size = self.max_encoding_message_size; 8675 8675 + let inner = self.inner.clone(); 8676 8676 + let fut = async move { 8677 8677 + let method = KeyclickClickSvc(inner); 8678 8678 + let codec = tonic::codec::ProstCodec::default(); 8679 8679 + let mut grpc = tonic::server::Grpc::new(codec) 8680 8680 + .apply_compression_config( 8681 8681 + accept_compression_encodings, 8682 8682 + send_compression_encodings, 8683 8683 + ) 8684 8684 + .apply_max_message_size_config( 8685 8685 + max_decoding_message_size, 8686 8686 + max_encoding_message_size, 8687 8687 + ); 8688 8688 + let res = grpc.unary(method, req).await; 8689 8689 + Ok(res) 8690 8690 + }; 8691 8691 + Box::pin(fut) 8692 8692 + } 8693 8693 + _ => { 8694 8694 + Box::pin(async move { 8695 8695 + let mut response = http::Response::new(empty_body()); 8696 8696 + let headers = response.headers_mut(); 8697 8697 + headers 8698 8698 + .insert( 8699 8699 + tonic::Status::GRPC_STATUS, 8700 8700 + (tonic::Code::Unimplemented as i32).into(), 8701 8701 + ); 8702 8702 + headers 8703 8703 + .insert( 8704 8704 + http::header::CONTENT_TYPE, 8705 8705 + tonic::metadata::GRPC_CONTENT_TYPE, 8706 8706 + ); 8707 8707 + Ok(response) 8708 8708 + }) 8709 8709 + } 8710 8710 + } 8711 8711 + } 8712 8712 + } 8713 8713 + impl<T> Clone for SoundServiceServer<T> { 8714 8714 + fn clone(&self) -> Self { 8715 8715 + let inner = self.inner.clone(); 8716 8716 + Self { 8717 8717 + inner, 8718 8718 + accept_compression_encodings: self.accept_compression_encodings, 8719 8719 + send_compression_encodings: self.send_compression_encodings, 8720 8720 + max_decoding_message_size: self.max_decoding_message_size, 8721 8721 + max_encoding_message_size: self.max_encoding_message_size, 8722 8722 + } 8723 8723 + } 8724 8724 + } 8725 8725 + /// Generated gRPC service name 8726 8726 + pub const SERVICE_NAME: &str = "rockbox.v1alpha1.SoundService"; 8727 8727 + impl<T> tonic::server::NamedService for SoundServiceServer<T> { 8728 8728 + const NAME: &'static str = SERVICE_NAME; 8729 8729 + } 8730 8730 + } 8731 8731 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 8732 8732 + pub struct GetRockboxVersionRequest {} 8733 8733 + #[derive(Clone, PartialEq, ::prost::Message)] 8734 8734 + pub struct GetRockboxVersionResponse { 8735 8735 + #[prost(string, tag = "1")] 8736 8736 + pub version: ::prost::alloc::string::String, 8737 8737 + } 8738 8738 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 8739 8739 + pub struct GetGlobalStatusRequest {} 8740 8740 + #[derive(Clone, Copy, PartialEq, ::prost::Message)] 8741 8741 + pub struct GetGlobalStatusResponse { 8742 8742 + #[prost(int32, tag = "1")] 8743 8743 + pub resume_index: i32, 8744 8744 + #[prost(uint32, tag = "2")] 8745 8745 + pub resume_crc32: u32, 8746 8746 + #[prost(uint32, tag = "3")] 8747 8747 + pub resume_elapsed: u32, 8748 8748 + #[prost(uint32, tag = "4")] 8749 8749 + pub resume_offset: u32, 8750 8750 + #[prost(int32, tag = "5")] 8751 8751 + pub runtime: i32, 8752 8752 + #[prost(int32, tag = "6")] 8753 8753 + pub topruntime: i32, 8754 8754 + #[prost(int32, tag = "7")] 8755 8755 + pub dircache_size: i32, 8756 8756 + #[prost(int32, tag = "8")] 8757 8757 + pub last_screen: i32, 8758 8758 + #[prost(int32, tag = "9")] 8759 8759 + pub viewer_icon_count: i32, 8760 8760 + #[prost(int32, tag = "10")] 8761 8761 + pub last_volume_change: i32, 8762 8762 + } 8763 8763 + /// Generated client implementations. 8764 8764 + pub mod system_service_client { 8765 8765 + #![allow( 8766 8766 + unused_variables, 8767 8767 + dead_code, 8768 8768 + missing_docs, 8769 8769 + clippy::wildcard_imports, 8770 8770 + clippy::let_unit_value, 8771 8771 + )] 8772 8772 + use tonic::codegen::*; 8773 8773 + use tonic::codegen::http::Uri; 8774 8774 + #[derive(Debug, Clone)] 8775 8775 + pub struct SystemServiceClient<T> { 8776 8776 + inner: tonic::client::Grpc<T>, 8777 8777 + } 8778 8778 + impl SystemServiceClient<tonic::transport::Channel> { 8779 8779 + /// Attempt to create a new client by connecting to a given endpoint. 8780 8780 + pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error> 8781 8781 + where 8782 8782 + D: TryInto<tonic::transport::Endpoint>, 8783 8783 + D::Error: Into<StdError>, 8784 8784 + { 8785 8785 + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; 8786 8786 + Ok(Self::new(conn)) 8787 8787 + } 8788 8788 + } 8789 8789 + impl<T> SystemServiceClient<T> 8790 8790 + where 8791 8791 + T: tonic::client::GrpcService<tonic::body::BoxBody>, 8792 8792 + T::Error: Into<StdError>, 8793 8793 + T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static, 8794 8794 + <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send, 8795 8795 + { 8796 8796 + pub fn new(inner: T) -> Self { 8797 8797 + let inner = tonic::client::Grpc::new(inner); 8798 8798 + Self { inner } 8799 8799 + } 8800 8800 + pub fn with_origin(inner: T, origin: Uri) -> Self { 8801 8801 + let inner = tonic::client::Grpc::with_origin(inner, origin); 8802 8802 + Self { inner } 8803 8803 + } 8804 8804 + pub fn with_interceptor<F>( 8805 8805 + inner: T, 8806 8806 + interceptor: F, 8807 8807 + ) -> SystemServiceClient<InterceptedService<T, F>> 8808 8808 + where 8809 8809 + F: tonic::service::Interceptor, 8810 8810 + T::ResponseBody: Default, 8811 8811 + T: tonic::codegen::Service< 8812 8812 + http::Request<tonic::body::BoxBody>, 8813 8813 + Response = http::Response< 8814 8814 + <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 8815 8815 + >, 8816 8816 + >, 8817 8817 + <T as tonic::codegen::Service< 8818 8818 + http::Request<tonic::body::BoxBody>, 8819 8819 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 8820 8820 + { 8821 8821 + SystemServiceClient::new(InterceptedService::new(inner, interceptor)) 8822 8822 + } 8823 8823 + /// Compress requests with the given encoding. 8824 8824 + /// 8825 8825 + /// This requires the server to support it otherwise it might respond with an 8826 8826 + /// error. 8827 8827 + #[must_use] 8828 8828 + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { 8829 8829 + self.inner = self.inner.send_compressed(encoding); 8830 8830 + self 8831 8831 + } 8832 8832 + /// Enable decompressing responses. 8833 8833 + #[must_use] 8834 8834 + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { 8835 8835 + self.inner = self.inner.accept_compressed(encoding); 8836 8836 + self 8837 8837 + } 8838 8838 + /// Limits the maximum size of a decoded message. 8839 8839 + /// 8840 8840 + /// Default: `4MB` 8841 8841 + #[must_use] 8842 8842 + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { 8843 8843 + self.inner = self.inner.max_decoding_message_size(limit); 8844 8844 + self 8845 8845 + } 8846 8846 + /// Limits the maximum size of an encoded message. 8847 8847 + /// 8848 8848 + /// Default: `usize::MAX` 8849 8849 + #[must_use] 8850 8850 + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { 8851 8851 + self.inner = self.inner.max_encoding_message_size(limit); 8852 8852 + self 8853 8853 + } 8854 8854 + pub async fn get_rockbox_version( 8855 8855 + &mut self, 8856 8856 + request: impl tonic::IntoRequest<super::GetRockboxVersionRequest>, 8857 8857 + ) -> std::result::Result< 8858 8858 + tonic::Response<super::GetRockboxVersionResponse>, 8859 8859 + tonic::Status, 8860 8860 + > { 8861 8861 + self.inner 8862 8862 + .ready() 8863 8863 + .await 8864 8864 + .map_err(|e| { 8865 8865 + tonic::Status::unknown( 8866 8866 + format!("Service was not ready: {}", e.into()), 8867 8867 + ) 8868 8868 + })?; 8869 8869 + let codec = tonic::codec::ProstCodec::default(); 8870 8870 + let path = http::uri::PathAndQuery::from_static( 8871 8871 + "/rockbox.v1alpha1.SystemService/GetRockboxVersion", 8872 8872 + ); 8873 8873 + let mut req = request.into_request(); 8874 8874 + req.extensions_mut() 8875 8875 + .insert( 8876 8876 + GrpcMethod::new( 8877 8877 + "rockbox.v1alpha1.SystemService", 8878 8878 + "GetRockboxVersion", 8879 8879 + ), 8880 8880 + ); 8881 8881 + self.inner.unary(req, path, codec).await 8882 8882 + } 8883 8883 + pub async fn get_global_status( 8884 8884 + &mut self, 8885 8885 + request: impl tonic::IntoRequest<super::GetGlobalStatusRequest>, 8886 8886 + ) -> std::result::Result< 8887 8887 + tonic::Response<super::GetGlobalStatusResponse>, 8888 8888 + tonic::Status, 8889 8889 + > { 8890 8890 + self.inner 8891 8891 + .ready() 8892 8892 + .await 8893 8893 + .map_err(|e| { 8894 8894 + tonic::Status::unknown( 8895 8895 + format!("Service was not ready: {}", e.into()), 8896 8896 + ) 8897 8897 + })?; 8898 8898 + let codec = tonic::codec::ProstCodec::default(); 8899 8899 + let path = http::uri::PathAndQuery::from_static( 8900 8900 + "/rockbox.v1alpha1.SystemService/GetGlobalStatus", 8901 8901 + ); 8902 8902 + let mut req = request.into_request(); 8903 8903 + req.extensions_mut() 8904 8904 + .insert( 8905 8905 + GrpcMethod::new("rockbox.v1alpha1.SystemService", "GetGlobalStatus"), 8906 8906 + ); 8907 8907 + self.inner.unary(req, path, codec).await 8908 8908 + } 8909 8909 + } 8910 8910 + } 8911 8911 + /// Generated server implementations. 8912 8912 + pub mod system_service_server { 8913 8913 + #![allow( 8914 8914 + unused_variables, 8915 8915 + dead_code, 8916 8916 + missing_docs, 8917 8917 + clippy::wildcard_imports, 8918 8918 + clippy::let_unit_value, 8919 8919 + )] 8920 8920 + use tonic::codegen::*; 8921 8921 + /// Generated trait containing gRPC methods that should be implemented for use with SystemServiceServer. 8922 8922 + #[async_trait] 8923 8923 + pub trait SystemService: std::marker::Send + std::marker::Sync + 'static { 8924 8924 + async fn get_rockbox_version( 8925 8925 + &self, 8926 8926 + request: tonic::Request<super::GetRockboxVersionRequest>, 8927 8927 + ) -> std::result::Result< 8928 8928 + tonic::Response<super::GetRockboxVersionResponse>, 8929 8929 + tonic::Status, 8930 8930 + >; 8931 8931 + async fn get_global_status( 8932 8932 + &self, 8933 8933 + request: tonic::Request<super::GetGlobalStatusRequest>, 8934 8934 + ) -> std::result::Result< 8935 8935 + tonic::Response<super::GetGlobalStatusResponse>, 8936 8936 + tonic::Status, 8937 8937 + >; 8938 8938 + } 8939 8939 + #[derive(Debug)] 8940 8940 + pub struct SystemServiceServer<T> { 8941 8941 + inner: Arc<T>, 8942 8942 + accept_compression_encodings: EnabledCompressionEncodings, 8943 8943 + send_compression_encodings: EnabledCompressionEncodings, 8944 8944 + max_decoding_message_size: Option<usize>, 8945 8945 + max_encoding_message_size: Option<usize>, 8946 8946 + } 8947 8947 + impl<T> SystemServiceServer<T> { 8948 8948 + pub fn new(inner: T) -> Self { 8949 8949 + Self::from_arc(Arc::new(inner)) 8950 8950 + } 8951 8951 + pub fn from_arc(inner: Arc<T>) -> Self { 8952 8952 + Self { 8953 8953 + inner, 8954 8954 + accept_compression_encodings: Default::default(), 8955 8955 + send_compression_encodings: Default::default(), 8956 8956 + max_decoding_message_size: None, 8957 8957 + max_encoding_message_size: None, 8958 8958 + } 8959 8959 + } 8960 8960 + pub fn with_interceptor<F>( 8961 8961 + inner: T, 8962 8962 + interceptor: F, 8963 8963 + ) -> InterceptedService<Self, F> 8964 8964 + where 8965 8965 + F: tonic::service::Interceptor, 8966 8966 + { 8967 8967 + InterceptedService::new(Self::new(inner), interceptor) 8968 8968 + } 8969 8969 + /// Enable decompressing requests with the given encoding. 8970 8970 + #[must_use] 8971 8971 + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { 8972 8972 + self.accept_compression_encodings.enable(encoding); 8973 8973 + self 8974 8974 + } 8975 8975 + /// Compress responses with the given encoding, if the client supports it. 8976 8976 + #[must_use] 8977 8977 + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { 8978 8978 + self.send_compression_encodings.enable(encoding); 8979 8979 + self 8980 8980 + } 8981 8981 + /// Limits the maximum size of a decoded message. 8982 8982 + /// 8983 8983 + /// Default: `4MB` 8984 8984 + #[must_use] 8985 8985 + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { 8986 8986 + self.max_decoding_message_size = Some(limit); 8987 8987 + self 8988 8988 + } 8989 8989 + /// Limits the maximum size of an encoded message. 8990 8990 + /// 8991 8991 + /// Default: `usize::MAX` 8992 8992 + #[must_use] 8993 8993 + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { 8994 8994 + self.max_encoding_message_size = Some(limit); 8995 8995 + self 8996 8996 + } 8997 8997 + } 8998 8998 + impl<T, B> tonic::codegen::Service<http::Request<B>> for SystemServiceServer<T> 8999 8999 + where 9000 9000 + T: SystemService, 9001 9001 + B: Body + std::marker::Send + 'static, 9002 9002 + B::Error: Into<StdError> + std::marker::Send + 'static, 9003 9003 + { 9004 9004 + type Response = http::Response<tonic::body::BoxBody>; 9005 9005 + type Error = std::convert::Infallible; 9006 9006 + type Future = BoxFuture<Self::Response, Self::Error>; 9007 9007 + fn poll_ready( 9008 9008 + &mut self, 9009 9009 + _cx: &mut Context<'_>, 9010 9010 + ) -> Poll<std::result::Result<(), Self::Error>> { 9011 9011 + Poll::Ready(Ok(())) 9012 9012 + } 9013 9013 + fn call(&mut self, req: http::Request<B>) -> Self::Future { 9014 9014 + match req.uri().path() { 9015 9015 + "/rockbox.v1alpha1.SystemService/GetRockboxVersion" => { 9016 9016 + #[allow(non_camel_case_types)] 9017 9017 + struct GetRockboxVersionSvc<T: SystemService>(pub Arc<T>); 9018 9018 + impl< 9019 9019 + T: SystemService, 9020 9020 + > tonic::server::UnaryService<super::GetRockboxVersionRequest> 9021 9021 + for GetRockboxVersionSvc<T> { 9022 9022 + type Response = super::GetRockboxVersionResponse; 9023 9023 + type Future = BoxFuture< 9024 9024 + tonic::Response<Self::Response>, 9025 9025 + tonic::Status, 9026 9026 + >; 9027 9027 + fn call( 9028 9028 + &mut self, 9029 9029 + request: tonic::Request<super::GetRockboxVersionRequest>, 9030 9030 + ) -> Self::Future { 9031 9031 + let inner = Arc::clone(&self.0); 9032 9032 + let fut = async move { 9033 9033 + <T as SystemService>::get_rockbox_version(&inner, request) 9034 9034 + .await 9035 9035 + }; 9036 9036 + Box::pin(fut) 9037 9037 + } 9038 9038 + } 9039 9039 + let accept_compression_encodings = self.accept_compression_encodings; 9040 9040 + let send_compression_encodings = self.send_compression_encodings; 9041 9041 + let max_decoding_message_size = self.max_decoding_message_size; 9042 9042 + let max_encoding_message_size = self.max_encoding_message_size; 9043 9043 + let inner = self.inner.clone(); 9044 9044 + let fut = async move { 9045 9045 + let method = GetRockboxVersionSvc(inner); 9046 9046 + let codec = tonic::codec::ProstCodec::default(); 9047 9047 + let mut grpc = tonic::server::Grpc::new(codec) 9048 9048 + .apply_compression_config( 9049 9049 + accept_compression_encodings, 9050 9050 + send_compression_encodings, 9051 9051 + ) 9052 9052 + .apply_max_message_size_config( 9053 9053 + max_decoding_message_size, 9054 9054 + max_encoding_message_size, 9055 9055 + ); 9056 9056 + let res = grpc.unary(method, req).await; 9057 9057 + Ok(res) 9058 9058 + }; 9059 9059 + Box::pin(fut) 9060 9060 + } 9061 9061 + "/rockbox.v1alpha1.SystemService/GetGlobalStatus" => { 9062 9062 + #[allow(non_camel_case_types)] 9063 9063 + struct GetGlobalStatusSvc<T: SystemService>(pub Arc<T>); 9064 9064 + impl< 9065 9065 + T: SystemService, 9066 9066 + > tonic::server::UnaryService<super::GetGlobalStatusRequest> 9067 9067 + for GetGlobalStatusSvc<T> { 9068 9068 + type Response = super::GetGlobalStatusResponse; 9069 9069 + type Future = BoxFuture< 9070 9070 + tonic::Response<Self::Response>, 9071 9071 + tonic::Status, 9072 9072 + >; 9073 9073 + fn call( 9074 9074 + &mut self, 9075 9075 + request: tonic::Request<super::GetGlobalStatusRequest>, 9076 9076 + ) -> Self::Future { 9077 9077 + let inner = Arc::clone(&self.0); 9078 9078 + let fut = async move { 9079 9079 + <T as SystemService>::get_global_status(&inner, request) 9080 9080 + .await 9081 9081 + }; 9082 9082 + Box::pin(fut) 9083 9083 + } 9084 9084 + } 9085 9085 + let accept_compression_encodings = self.accept_compression_encodings; 9086 9086 + let send_compression_encodings = self.send_compression_encodings; 9087 9087 + let max_decoding_message_size = self.max_decoding_message_size; 9088 9088 + let max_encoding_message_size = self.max_encoding_message_size; 9089 9089 + let inner = self.inner.clone(); 9090 9090 + let fut = async move { 9091 9091 + let method = GetGlobalStatusSvc(inner); 9092 9092 + let codec = tonic::codec::ProstCodec::default(); 9093 9093 + let mut grpc = tonic::server::Grpc::new(codec) 9094 9094 + .apply_compression_config( 9095 9095 + accept_compression_encodings, 9096 9096 + send_compression_encodings, 9097 9097 + ) 9098 9098 + .apply_max_message_size_config( 9099 9099 + max_decoding_message_size, 9100 9100 + max_encoding_message_size, 9101 9101 + ); 9102 9102 + let res = grpc.unary(method, req).await; 9103 9103 + Ok(res) 9104 9104 + }; 9105 9105 + Box::pin(fut) 9106 9106 + } 9107 9107 + _ => { 9108 9108 + Box::pin(async move { 9109 9109 + let mut response = http::Response::new(empty_body()); 9110 9110 + let headers = response.headers_mut(); 9111 9111 + headers 9112 9112 + .insert( 9113 9113 + tonic::Status::GRPC_STATUS, 9114 9114 + (tonic::Code::Unimplemented as i32).into(), 9115 9115 + ); 9116 9116 + headers 9117 9117 + .insert( 9118 9118 + http::header::CONTENT_TYPE, 9119 9119 + tonic::metadata::GRPC_CONTENT_TYPE, 9120 9120 + ); 9121 9121 + Ok(response) 9122 9122 + }) 9123 9123 + } 9124 9124 + } 9125 9125 + } 9126 9126 + } 9127 9127 + impl<T> Clone for SystemServiceServer<T> { 9128 9128 + fn clone(&self) -> Self { 9129 9129 + let inner = self.inner.clone(); 9130 9130 + Self { 9131 9131 + inner, 9132 9132 + accept_compression_encodings: self.accept_compression_encodings, 9133 9133 + send_compression_encodings: self.send_compression_encodings, 9134 9134 + max_decoding_message_size: self.max_decoding_message_size, 9135 9135 + max_encoding_message_size: self.max_encoding_message_size, 9136 9136 + } 9137 9137 + } 9138 9138 + } 9139 9139 + /// Generated gRPC service name 9140 9140 + pub const SERVICE_NAME: &str = "rockbox.v1alpha1.SystemService"; 9141 9141 + impl<T> tonic::server::NamedService for SystemServiceServer<T> { 9142 9142 + const NAME: &'static str = SERVICE_NAME; 9143 9143 + } 9144 9144 + }

crates/controls/src/api/rockbox_descriptor.bin

This is a binary file and will not be displayed.

+349

crates/controls/src/lib.rs

··· 1 1 + use anyhow::Error; 2 2 + use souvlaki::{ 3 3 + MediaControlEvent, MediaControls, MediaMetadata, MediaPlayback, MediaPosition, PlatformConfig, 4 4 + }; 5 5 + use std::env; 6 6 + use std::sync::atomic::{AtomicBool, Ordering}; 7 7 + use std::sync::{mpsc, Arc}; 8 8 + use std::time::Duration; 9 9 + use winit::application::ApplicationHandler; 10 10 + use winit::event::WindowEvent; 11 11 + use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop}; 12 12 + use winit::window::WindowId; 13 13 + 14 14 + use crate::api::rockbox::v1alpha1::playback_service_client::PlaybackServiceClient; 15 15 + use crate::api::rockbox::v1alpha1::{StreamCurrentTrackRequest, StreamStatusRequest}; 16 16 + 17 17 + pub mod api { 18 18 + #[path = ""] 19 19 + pub mod rockbox { 20 20 + 21 21 + #[path = "rockbox.v1alpha1.rs"] 22 22 + pub mod v1alpha1; 23 23 + } 24 24 + } 25 25 + 26 26 + // Commands to send to the media controls from async tasks 27 27 + #[derive(Debug)] 28 28 + enum MediaCommand { 29 29 + SetMetadata { 30 30 + title: String, 31 31 + artist: String, 32 32 + album: String, 33 33 + duration: Duration, 34 34 + cover_url: Option<String>, 35 35 + }, 36 36 + Play, 37 37 + Pause, 38 38 + Next, 39 39 + Previous, 40 40 + SetMediaPosition((MediaPosition, bool)), 41 41 + } 42 42 + 43 43 + struct App { 44 44 + controls: MediaControls, 45 45 + command_receiver: mpsc::Receiver<MediaCommand>, 46 46 + media_event_sender: tokio::sync::mpsc::UnboundedSender<MediaControlEvent>, 47 47 + } 48 48 + 49 49 + impl ApplicationHandler for App { 50 50 + fn resumed(&mut self, _event_loop: &ActiveEventLoop) { 51 51 + println!("App resumed, media controls ready!"); 52 52 + } 53 53 + 54 54 + fn window_event(&mut self, _event_loop: &ActiveEventLoop, _id: WindowId, _event: WindowEvent) {} 55 55 + 56 56 + fn about_to_wait(&mut self, _event_loop: &ActiveEventLoop) { 57 57 + // Process all pending commands from async tasks 58 58 + while let Ok(cmd) = self.command_receiver.try_recv() { 59 59 + match cmd { 60 60 + MediaCommand::SetMetadata { 61 61 + title, 62 62 + artist, 63 63 + album, 64 64 + duration, 65 65 + cover_url, 66 66 + } => { 67 67 + // Set playback state first 68 68 + if let Err(e) = self 69 69 + .controls 70 70 + .set_playback(MediaPlayback::Playing { progress: None }) 71 71 + { 72 72 + eprintln!("Failed to set playback state: {}", e); 73 73 + } 74 74 + 75 75 + // Then set metadata 76 76 + if let Err(e) = self.controls.set_metadata(MediaMetadata { 77 77 + title: Some(&title), 78 78 + artist: Some(&artist), 79 79 + album: Some(&album), 80 80 + duration: Some(duration), 81 81 + cover_url: cover_url.as_deref(), 82 82 + }) { 83 83 + eprintln!("Failed to set metadata: {}", e); 84 84 + } 85 85 + } 86 86 + MediaCommand::Play => { 87 87 + if let Err(e) = self 88 88 + .controls 89 89 + .set_playback(MediaPlayback::Playing { progress: None }) 90 90 + { 91 91 + eprintln!("Failed to set playback state: {}", e); 92 92 + } 93 93 + } 94 94 + MediaCommand::Pause => { 95 95 + if let Err(e) = self 96 96 + .controls 97 97 + .set_playback(MediaPlayback::Paused { progress: None }) 98 98 + { 99 99 + eprintln!("Failed to set playback state: {}", e); 100 100 + } 101 101 + } 102 102 + MediaCommand::SetMediaPosition((position, playing)) => { 103 103 + if let Err(e) = self.controls.set_playback(match playing { 104 104 + true => MediaPlayback::Playing { 105 105 + progress: Some(position), 106 106 + }, 107 107 + false => MediaPlayback::Paused { 108 108 + progress: Some(position), 109 109 + }, 110 110 + }) { 111 111 + eprintln!("Failed to set playback state: {}", e); 112 112 + } 113 113 + } 114 114 + _ => {} 115 115 + } 116 116 + } 117 117 + } 118 118 + } 119 119 + 120 120 + /// Start the media controls system. 121 121 + /// This function blocks and runs the event loop on the main thread. 122 122 + pub fn run_media_controls() -> Result<(), Box<dyn std::error::Error>> { 123 123 + // Channel for sending commands TO the media controls (from async tasks) 124 124 + let (command_sender, command_receiver) = mpsc::channel::<MediaCommand>(); 125 125 + 126 126 + // Channel for receiving events FROM the media controls (to async tasks) 127 127 + let (media_event_sender, media_event_receiver) = 128 128 + tokio::sync::mpsc::unbounded_channel::<MediaControlEvent>(); 129 129 + 130 130 + // Shared playing state between status and metadata tasks 131 131 + let is_playing = Arc::new(AtomicBool::new(false)); 132 132 + 133 133 + let sender = command_sender.clone(); 134 134 + let playing_state = Arc::clone(&is_playing); 135 135 + std::thread::spawn(move || { 136 136 + println!(">> spawn metadata update task"); 137 137 + let runtime = tokio::runtime::Runtime::new().unwrap(); 138 138 + match runtime.block_on(spawn_metadata_update_task(sender.clone(), playing_state)) { 139 139 + Ok(_) => println!("Metadata update task completed"), 140 140 + Err(e) => eprintln!("Metadata update task failed: {}", e), 141 141 + } 142 142 + }); 143 143 + 144 144 + let sender = command_sender.clone(); 145 145 + std::thread::spawn(move || { 146 146 + println!(">> spawn event handler task"); 147 147 + let runtime = tokio::runtime::Runtime::new().unwrap(); 148 148 + match runtime.block_on(spawn_event_handler_task( 149 149 + sender.clone(), 150 150 + media_event_receiver, 151 151 + )) { 152 152 + Ok(()) => println!("Event handler task completed"), 153 153 + Err(e) => eprintln!("Event handler task failed: {}", e), 154 154 + } 155 155 + }); 156 156 + 157 157 + let sender = command_sender.clone(); 158 158 + let playing_state = Arc::clone(&is_playing); 159 159 + std::thread::spawn(move || { 160 160 + println!(">> spawn status update task"); 161 161 + let runtime = tokio::runtime::Runtime::new().unwrap(); 162 162 + match runtime.block_on(spawn_status_update_task(sender.clone(), playing_state)) { 163 163 + Ok(_) => println!("Status update task completed"), 164 164 + Err(e) => eprintln!("Status update task failed: {}", e), 165 165 + } 166 166 + }); 167 167 + 168 168 + // Run the event loop on the main thread (required for macOS) 169 169 + let event_loop = EventLoop::new()?; 170 170 + event_loop.set_control_flow(ControlFlow::Poll); 171 171 + 172 172 + let mut controls = MediaControls::new(PlatformConfig { 173 173 + display_name: "Rockbox", 174 174 + dbus_name: "tsirysndr.rockbox", 175 175 + hwnd: None, 176 176 + })?; 177 177 + 178 178 + // Attach event handler - forward events to async task 179 179 + let event_sender = media_event_sender.clone(); 180 180 + controls.attach(move |event| { 181 181 + let _ = event_sender.send(event); 182 182 + })?; 183 183 + 184 184 + let mut app = App { 185 185 + controls, 186 186 + command_receiver, 187 187 + media_event_sender, 188 188 + }; 189 189 + 190 190 + event_loop.run_app(&mut app)?; 191 191 + 192 192 + Ok(()) 193 193 + } 194 194 + 195 195 + async fn spawn_metadata_update_task( 196 196 + command_sender: mpsc::Sender<MediaCommand>, 197 197 + is_playing: Arc<AtomicBool>, 198 198 + ) -> Result<(), Error> { 199 199 + let host = env::var("ROCKBOX_HOST").unwrap_or_else(|_| "localhost".to_string()); 200 200 + let port = env::var("ROCKBOX_PORT").unwrap_or_else(|_| "6061".to_string()); 201 201 + 202 202 + let url = format!("tcp://{}:{}", host, port); 203 203 + 204 204 + let mut client = PlaybackServiceClient::connect(url).await?; 205 205 + 206 206 + let mut stream = client 207 207 + .stream_current_track(StreamCurrentTrackRequest {}) 208 208 + .await? 209 209 + .into_inner(); 210 210 + 211 211 + let asset_host = env::var("ROCKBOX_GRAPHQL_HOST").unwrap_or_else(|_| "localhost".to_string()); 212 212 + let asset_port = env::var("ROCKBOX_GRAPHQL_PORT").unwrap_or_else(|_| "6062".to_string()); 213 213 + 214 214 + let mut previous_album_art: Option<String> = None; 215 215 + let mut current_cover_url: Option<String> = None; 216 216 + 217 217 + while let Some(track) = stream.message().await? { 218 218 + // Only update cover_url if album_art has changed 219 219 + if track.album_art != previous_album_art { 220 220 + previous_album_art.clone_from(&track.album_art); 221 221 + current_cover_url = match &track.album_art { 222 222 + Some(album_art) => match album_art.starts_with("http") { 223 223 + true => Some(album_art.clone()), 224 224 + false => Some(format!( 225 225 + "http://{}:{}/covers/{}", 226 226 + asset_host, asset_port, album_art 227 227 + )), 228 228 + }, 229 229 + None => None, 230 230 + }; 231 231 + } 232 232 + 233 233 + let cmd = MediaCommand::SetMetadata { 234 234 + title: track.title, 235 235 + artist: track.artist, 236 236 + album: track.album, 237 237 + duration: Duration::from_millis(track.length), 238 238 + cover_url: current_cover_url.clone(), 239 239 + }; 240 240 + 241 241 + command_sender.send(cmd)?; 242 242 + 243 243 + // Get current playing state and send position update 244 244 + let playing = is_playing.load(Ordering::Relaxed); 245 245 + command_sender.send(MediaCommand::SetMediaPosition(( 246 246 + MediaPosition(Duration::from_millis(track.elapsed)), 247 247 + playing, 248 248 + )))?; 249 249 + } 250 250 + 251 251 + Ok(()) 252 252 + } 253 253 + 254 254 + async fn spawn_event_handler_task( 255 255 + command_sender: std::sync::mpsc::Sender<MediaCommand>, 256 256 + mut receiver: tokio::sync::mpsc::UnboundedReceiver<MediaControlEvent>, 257 257 + ) -> Result<(), Error> { 258 258 + while let Some(event) = receiver.recv().await { 259 259 + match event { 260 260 + MediaControlEvent::Play => { 261 261 + println!("[MediaControl] Play"); 262 262 + // TODO: Add your play logic here 263 263 + command_sender.send(MediaCommand::Play)?; 264 264 + } 265 265 + MediaControlEvent::Pause => { 266 266 + println!("[MediaControl] Pause"); 267 267 + // TODO: Add your pause logic here 268 268 + command_sender.send(MediaCommand::Pause)?; 269 269 + } 270 270 + MediaControlEvent::Next => { 271 271 + println!("[MediaControl] Next"); 272 272 + // TODO: Add your next track logic here 273 273 + command_sender.send(MediaCommand::Next)?; 274 274 + } 275 275 + MediaControlEvent::Previous => { 276 276 + println!("[MediaControl] Previous"); 277 277 + // TODO: Add your previous track logic here 278 278 + command_sender.send(MediaCommand::Previous)?; 279 279 + } 280 280 + MediaControlEvent::Seek(_) => { 281 281 + println!("[MediaControl] Seek"); 282 282 + } 283 283 + MediaControlEvent::Toggle => { 284 284 + println!("[MediaControl] Toggle"); 285 285 + } 286 286 + MediaControlEvent::Stop => { 287 287 + println!("[MediaControl] Stop"); 288 288 + } 289 289 + MediaControlEvent::SeekBy(seek_direction, duration) => { 290 290 + println!("[MediaControl] SeekBy {:?} {:?}", seek_direction, duration); 291 291 + } 292 292 + MediaControlEvent::SetPosition(media_position) => { 293 293 + println!("[MediaControl] SetPosition {:?}", media_position); 294 294 + } 295 295 + MediaControlEvent::SetVolume(volume) => { 296 296 + println!("[MediaControl] SetVolume {}", volume); 297 297 + } 298 298 + MediaControlEvent::OpenUri(uri) => { 299 299 + println!("[MediaControl] OpenUri {}", uri); 300 300 + } 301 301 + MediaControlEvent::Raise => { 302 302 + println!("[MediaControl] Raise"); 303 303 + } 304 304 + MediaControlEvent::Quit => { 305 305 + println!("[MediaControl] Quit"); 306 306 + } 307 307 + } 308 308 + } 309 309 + 310 310 + println!(">> Event receiver closed"); 311 311 + 312 312 + Ok(()) 313 313 + } 314 314 + 315 315 + async fn spawn_status_update_task( 316 316 + command_sender: mpsc::Sender<MediaCommand>, 317 317 + is_playing: Arc<AtomicBool>, 318 318 + ) -> Result<(), Error> { 319 319 + let host = env::var("ROCKBOX_HOST").unwrap_or_else(|_| "localhost".to_string()); 320 320 + let port = env::var("ROCKBOX_PORT").unwrap_or_else(|_| "6061".to_string()); 321 321 + 322 322 + let url = format!("tcp://{}:{}", host, port); 323 323 + 324 324 + let mut client = PlaybackServiceClient::connect(url).await?; 325 325 + 326 326 + let mut stream = client 327 327 + .stream_status(StreamStatusRequest {}) 328 328 + .await? 329 329 + .into_inner(); 330 330 + 331 331 + while let Some(response) = stream.message().await? { 332 332 + match response.status { 333 333 + 1 => { 334 334 + is_playing.store(true, Ordering::Relaxed); 335 335 + command_sender.send(MediaCommand::Play)?; 336 336 + } 337 337 + 3 => { 338 338 + is_playing.store(false, Ordering::Relaxed); 339 339 + command_sender.send(MediaCommand::Pause)?; 340 340 + } 341 341 + _ => { 342 342 + is_playing.store(false, Ordering::Relaxed); 343 343 + command_sender.send(MediaCommand::Pause)?; 344 344 + } 345 345 + }; 346 346 + } 347 347 + 348 348 + Ok(()) 349 349 + }

+1 -1

crates/mpd/src/lib.rs

··· 31 31 sound_service_client::SoundServiceClient, system_service_client::SystemServiceClient, 32 32 GetCurrentRequest, GetGlobalStatusRequest, PlaylistResumeRequest, 33 33 }; 34 34 - use rockbox_sys::{playback::current_track, types::user_settings::UserSettings}; 34 34 + use rockbox_sys::types::user_settings::UserSettings; 35 35 use sqlx::{Pool, Sqlite}; 36 36 use std::{env, sync::Arc, thread, time::Duration}; 37 37 use tokio::{

+2470 -1224

crates/rocksky/src/api/rockbox.v1alpha1.rs

··· 43 43 dead_code, 44 44 missing_docs, 45 45 clippy::wildcard_imports, 46 46 - clippy::let_unit_value 46 46 + clippy::let_unit_value, 47 47 )] 48 48 - use tonic::codegen::http::Uri; 49 48 use tonic::codegen::*; 49 49 + use tonic::codegen::http::Uri; 50 50 #[derive(Debug, Clone)] 51 51 pub struct BrowseServiceClient<T> { 52 52 inner: tonic::client::Grpc<T>, ··· 90 90 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 91 91 >, 92 92 >, 93 93 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 94 94 - Into<StdError> + std::marker::Send + std::marker::Sync, 93 93 + <T as tonic::codegen::Service< 94 94 + http::Request<tonic::body::BoxBody>, 95 95 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 95 96 { 96 97 BrowseServiceClient::new(InterceptedService::new(inner, interceptor)) 97 98 } ··· 129 130 pub async fn tree_get_entries( 130 131 &mut self, 131 132 request: impl tonic::IntoRequest<super::TreeGetEntriesRequest>, 132 132 - ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status> 133 133 - { 134 134 - self.inner.ready().await.map_err(|e| { 135 135 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 136 136 - })?; 133 133 + ) -> std::result::Result< 134 134 + tonic::Response<super::TreeGetEntriesResponse>, 135 135 + tonic::Status, 136 136 + > { 137 137 + self.inner 138 138 + .ready() 139 139 + .await 140 140 + .map_err(|e| { 141 141 + tonic::Status::unknown( 142 142 + format!("Service was not ready: {}", e.into()), 143 143 + ) 144 144 + })?; 137 145 let codec = tonic::codec::ProstCodec::default(); 138 146 let path = http::uri::PathAndQuery::from_static( 139 147 "/rockbox.v1alpha1.BrowseService/TreeGetEntries", 140 148 ); 141 149 let mut req = request.into_request(); 142 142 - req.extensions_mut().insert(GrpcMethod::new( 143 143 - "rockbox.v1alpha1.BrowseService", 144 144 - "TreeGetEntries", 145 145 - )); 150 150 + req.extensions_mut() 151 151 + .insert( 152 152 + GrpcMethod::new("rockbox.v1alpha1.BrowseService", "TreeGetEntries"), 153 153 + ); 146 154 self.inner.unary(req, path, codec).await 147 155 } 148 156 } ··· 154 162 dead_code, 155 163 missing_docs, 156 164 clippy::wildcard_imports, 157 157 - clippy::let_unit_value 165 165 + clippy::let_unit_value, 158 166 )] 159 167 use tonic::codegen::*; 160 168 /// Generated trait containing gRPC methods that should be implemented for use with BrowseServiceServer. ··· 163 171 async fn tree_get_entries( 164 172 &self, 165 173 request: tonic::Request<super::TreeGetEntriesRequest>, 166 166 - ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status>; 174 174 + ) -> std::result::Result< 175 175 + tonic::Response<super::TreeGetEntriesResponse>, 176 176 + tonic::Status, 177 177 + >; 167 178 } 168 179 #[derive(Debug)] 169 180 pub struct BrowseServiceServer<T> { ··· 186 197 max_encoding_message_size: None, 187 198 } 188 199 } 189 189 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 200 200 + pub fn with_interceptor<F>( 201 201 + inner: T, 202 202 + interceptor: F, 203 203 + ) -> InterceptedService<Self, F> 190 204 where 191 205 F: tonic::service::Interceptor, 192 206 { ··· 241 255 "/rockbox.v1alpha1.BrowseService/TreeGetEntries" => { 242 256 #[allow(non_camel_case_types)] 243 257 struct TreeGetEntriesSvc<T: BrowseService>(pub Arc<T>); 244 244 - impl<T: BrowseService> tonic::server::UnaryService<super::TreeGetEntriesRequest> 245 245 - for TreeGetEntriesSvc<T> 246 246 - { 258 258 + impl< 259 259 + T: BrowseService, 260 260 + > tonic::server::UnaryService<super::TreeGetEntriesRequest> 261 261 + for TreeGetEntriesSvc<T> { 247 262 type Response = super::TreeGetEntriesResponse; 248 248 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 263 263 + type Future = BoxFuture< 264 264 + tonic::Response<Self::Response>, 265 265 + tonic::Status, 266 266 + >; 249 267 fn call( 250 268 &mut self, 251 269 request: tonic::Request<super::TreeGetEntriesRequest>, 252 270 ) -> Self::Future { 253 271 let inner = Arc::clone(&self.0); 254 272 let fut = async move { 255 255 - <T as BrowseService>::tree_get_entries(&inner, request).await 273 273 + <T as BrowseService>::tree_get_entries(&inner, request) 274 274 + .await 256 275 }; 257 276 Box::pin(fut) 258 277 } ··· 279 298 }; 280 299 Box::pin(fut) 281 300 } 282 282 - _ => Box::pin(async move { 283 283 - let mut response = http::Response::new(empty_body()); 284 284 - let headers = response.headers_mut(); 285 285 - headers.insert( 286 286 - tonic::Status::GRPC_STATUS, 287 287 - (tonic::Code::Unimplemented as i32).into(), 288 288 - ); 289 289 - headers.insert( 290 290 - http::header::CONTENT_TYPE, 291 291 - tonic::metadata::GRPC_CONTENT_TYPE, 292 292 - ); 293 293 - Ok(response) 294 294 - }), 301 301 + _ => { 302 302 + Box::pin(async move { 303 303 + let mut response = http::Response::new(empty_body()); 304 304 + let headers = response.headers_mut(); 305 305 + headers 306 306 + .insert( 307 307 + tonic::Status::GRPC_STATUS, 308 308 + (tonic::Code::Unimplemented as i32).into(), 309 309 + ); 310 310 + headers 311 311 + .insert( 312 312 + http::header::CONTENT_TYPE, 313 313 + tonic::metadata::GRPC_CONTENT_TYPE, 314 314 + ); 315 315 + Ok(response) 316 316 + }) 317 317 + } 295 318 } 296 319 } 297 320 } ··· 519 542 dead_code, 520 543 missing_docs, 521 544 clippy::wildcard_imports, 522 522 - clippy::let_unit_value 545 545 + clippy::let_unit_value, 523 546 )] 524 524 - use tonic::codegen::http::Uri; 525 547 use tonic::codegen::*; 548 548 + use tonic::codegen::http::Uri; 526 549 #[derive(Debug, Clone)] 527 550 pub struct LibraryServiceClient<T> { 528 551 inner: tonic::client::Grpc<T>, ··· 566 589 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 567 590 >, 568 591 >, 569 569 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 570 570 - Into<StdError> + std::marker::Send + std::marker::Sync, 592 592 + <T as tonic::codegen::Service< 593 593 + http::Request<tonic::body::BoxBody>, 594 594 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 571 595 { 572 596 LibraryServiceClient::new(InterceptedService::new(inner, interceptor)) 573 597 } ··· 605 629 pub async fn get_albums( 606 630 &mut self, 607 631 request: impl tonic::IntoRequest<super::GetAlbumsRequest>, 608 608 - ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status> { 609 609 - self.inner.ready().await.map_err(|e| { 610 610 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 611 611 - })?; 632 632 + ) -> std::result::Result< 633 633 + tonic::Response<super::GetAlbumsResponse>, 634 634 + tonic::Status, 635 635 + > { 636 636 + self.inner 637 637 + .ready() 638 638 + .await 639 639 + .map_err(|e| { 640 640 + tonic::Status::unknown( 641 641 + format!("Service was not ready: {}", e.into()), 642 642 + ) 643 643 + })?; 612 644 let codec = tonic::codec::ProstCodec::default(); 613 613 - let path = 614 614 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbums"); 645 645 + let path = http::uri::PathAndQuery::from_static( 646 646 + "/rockbox.v1alpha1.LibraryService/GetAlbums", 647 647 + ); 615 648 let mut req = request.into_request(); 616 616 - req.extensions_mut().insert(GrpcMethod::new( 617 617 - "rockbox.v1alpha1.LibraryService", 618 618 - "GetAlbums", 619 619 - )); 649 649 + req.extensions_mut() 650 650 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbums")); 620 651 self.inner.unary(req, path, codec).await 621 652 } 622 653 pub async fn get_artists( 623 654 &mut self, 624 655 request: impl tonic::IntoRequest<super::GetArtistsRequest>, 625 625 - ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status> 626 626 - { 627 627 - self.inner.ready().await.map_err(|e| { 628 628 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 629 629 - })?; 656 656 + ) -> std::result::Result< 657 657 + tonic::Response<super::GetArtistsResponse>, 658 658 + tonic::Status, 659 659 + > { 660 660 + self.inner 661 661 + .ready() 662 662 + .await 663 663 + .map_err(|e| { 664 664 + tonic::Status::unknown( 665 665 + format!("Service was not ready: {}", e.into()), 666 666 + ) 667 667 + })?; 630 668 let codec = tonic::codec::ProstCodec::default(); 631 631 - let path = 632 632 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtists"); 669 669 + let path = http::uri::PathAndQuery::from_static( 670 670 + "/rockbox.v1alpha1.LibraryService/GetArtists", 671 671 + ); 633 672 let mut req = request.into_request(); 634 634 - req.extensions_mut().insert(GrpcMethod::new( 635 635 - "rockbox.v1alpha1.LibraryService", 636 636 - "GetArtists", 637 637 - )); 673 673 + req.extensions_mut() 674 674 + .insert( 675 675 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtists"), 676 676 + ); 638 677 self.inner.unary(req, path, codec).await 639 678 } 640 679 pub async fn get_tracks( 641 680 &mut self, 642 681 request: impl tonic::IntoRequest<super::GetTracksRequest>, 643 643 - ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status> { 644 644 - self.inner.ready().await.map_err(|e| { 645 645 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 646 646 - })?; 682 682 + ) -> std::result::Result< 683 683 + tonic::Response<super::GetTracksResponse>, 684 684 + tonic::Status, 685 685 + > { 686 686 + self.inner 687 687 + .ready() 688 688 + .await 689 689 + .map_err(|e| { 690 690 + tonic::Status::unknown( 691 691 + format!("Service was not ready: {}", e.into()), 692 692 + ) 693 693 + })?; 647 694 let codec = tonic::codec::ProstCodec::default(); 648 648 - let path = 649 649 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTracks"); 695 695 + let path = http::uri::PathAndQuery::from_static( 696 696 + "/rockbox.v1alpha1.LibraryService/GetTracks", 697 697 + ); 650 698 let mut req = request.into_request(); 651 651 - req.extensions_mut().insert(GrpcMethod::new( 652 652 - "rockbox.v1alpha1.LibraryService", 653 653 - "GetTracks", 654 654 - )); 699 699 + req.extensions_mut() 700 700 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTracks")); 655 701 self.inner.unary(req, path, codec).await 656 702 } 657 703 pub async fn get_album( 658 704 &mut self, 659 705 request: impl tonic::IntoRequest<super::GetAlbumRequest>, 660 660 - ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status> { 661 661 - self.inner.ready().await.map_err(|e| { 662 662 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 663 663 - })?; 706 706 + ) -> std::result::Result< 707 707 + tonic::Response<super::GetAlbumResponse>, 708 708 + tonic::Status, 709 709 + > { 710 710 + self.inner 711 711 + .ready() 712 712 + .await 713 713 + .map_err(|e| { 714 714 + tonic::Status::unknown( 715 715 + format!("Service was not ready: {}", e.into()), 716 716 + ) 717 717 + })?; 664 718 let codec = tonic::codec::ProstCodec::default(); 665 665 - let path = 666 666 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbum"); 719 719 + let path = http::uri::PathAndQuery::from_static( 720 720 + "/rockbox.v1alpha1.LibraryService/GetAlbum", 721 721 + ); 667 722 let mut req = request.into_request(); 668 668 - req.extensions_mut().insert(GrpcMethod::new( 669 669 - "rockbox.v1alpha1.LibraryService", 670 670 - "GetAlbum", 671 671 - )); 723 723 + req.extensions_mut() 724 724 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbum")); 672 725 self.inner.unary(req, path, codec).await 673 726 } 674 727 pub async fn get_artist( 675 728 &mut self, 676 729 request: impl tonic::IntoRequest<super::GetArtistRequest>, 677 677 - ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status> { 678 678 - self.inner.ready().await.map_err(|e| { 679 679 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 680 680 - })?; 730 730 + ) -> std::result::Result< 731 731 + tonic::Response<super::GetArtistResponse>, 732 732 + tonic::Status, 733 733 + > { 734 734 + self.inner 735 735 + .ready() 736 736 + .await 737 737 + .map_err(|e| { 738 738 + tonic::Status::unknown( 739 739 + format!("Service was not ready: {}", e.into()), 740 740 + ) 741 741 + })?; 681 742 let codec = tonic::codec::ProstCodec::default(); 682 682 - let path = 683 683 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtist"); 743 743 + let path = http::uri::PathAndQuery::from_static( 744 744 + "/rockbox.v1alpha1.LibraryService/GetArtist", 745 745 + ); 684 746 let mut req = request.into_request(); 685 685 - req.extensions_mut().insert(GrpcMethod::new( 686 686 - "rockbox.v1alpha1.LibraryService", 687 687 - "GetArtist", 688 688 - )); 747 747 + req.extensions_mut() 748 748 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtist")); 689 749 self.inner.unary(req, path, codec).await 690 750 } 691 751 pub async fn get_track( 692 752 &mut self, 693 753 request: impl tonic::IntoRequest<super::GetTrackRequest>, 694 694 - ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status> { 695 695 - self.inner.ready().await.map_err(|e| { 696 696 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 697 697 - })?; 754 754 + ) -> std::result::Result< 755 755 + tonic::Response<super::GetTrackResponse>, 756 756 + tonic::Status, 757 757 + > { 758 758 + self.inner 759 759 + .ready() 760 760 + .await 761 761 + .map_err(|e| { 762 762 + tonic::Status::unknown( 763 763 + format!("Service was not ready: {}", e.into()), 764 764 + ) 765 765 + })?; 698 766 let codec = tonic::codec::ProstCodec::default(); 699 699 - let path = 700 700 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTrack"); 767 767 + let path = http::uri::PathAndQuery::from_static( 768 768 + "/rockbox.v1alpha1.LibraryService/GetTrack", 769 769 + ); 701 770 let mut req = request.into_request(); 702 702 - req.extensions_mut().insert(GrpcMethod::new( 703 703 - "rockbox.v1alpha1.LibraryService", 704 704 - "GetTrack", 705 705 - )); 771 771 + req.extensions_mut() 772 772 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTrack")); 706 773 self.inner.unary(req, path, codec).await 707 774 } 708 775 pub async fn like_track( 709 776 &mut self, 710 777 request: impl tonic::IntoRequest<super::LikeTrackRequest>, 711 711 - ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status> { 712 712 - self.inner.ready().await.map_err(|e| { 713 713 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 714 714 - })?; 778 778 + ) -> std::result::Result< 779 779 + tonic::Response<super::LikeTrackResponse>, 780 780 + tonic::Status, 781 781 + > { 782 782 + self.inner 783 783 + .ready() 784 784 + .await 785 785 + .map_err(|e| { 786 786 + tonic::Status::unknown( 787 787 + format!("Service was not ready: {}", e.into()), 788 788 + ) 789 789 + })?; 715 790 let codec = tonic::codec::ProstCodec::default(); 716 716 - let path = 717 717 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeTrack"); 791 791 + let path = http::uri::PathAndQuery::from_static( 792 792 + "/rockbox.v1alpha1.LibraryService/LikeTrack", 793 793 + ); 718 794 let mut req = request.into_request(); 719 719 - req.extensions_mut().insert(GrpcMethod::new( 720 720 - "rockbox.v1alpha1.LibraryService", 721 721 - "LikeTrack", 722 722 - )); 795 795 + req.extensions_mut() 796 796 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeTrack")); 723 797 self.inner.unary(req, path, codec).await 724 798 } 725 799 pub async fn unlike_track( 726 800 &mut self, 727 801 request: impl tonic::IntoRequest<super::UnlikeTrackRequest>, 728 728 - ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status> 729 729 - { 730 730 - self.inner.ready().await.map_err(|e| { 731 731 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 732 732 - })?; 802 802 + ) -> std::result::Result< 803 803 + tonic::Response<super::UnlikeTrackResponse>, 804 804 + tonic::Status, 805 805 + > { 806 806 + self.inner 807 807 + .ready() 808 808 + .await 809 809 + .map_err(|e| { 810 810 + tonic::Status::unknown( 811 811 + format!("Service was not ready: {}", e.into()), 812 812 + ) 813 813 + })?; 733 814 let codec = tonic::codec::ProstCodec::default(); 734 815 let path = http::uri::PathAndQuery::from_static( 735 816 "/rockbox.v1alpha1.LibraryService/UnlikeTrack", 736 817 ); 737 818 let mut req = request.into_request(); 738 738 - req.extensions_mut().insert(GrpcMethod::new( 739 739 - "rockbox.v1alpha1.LibraryService", 740 740 - "UnlikeTrack", 741 741 - )); 819 819 + req.extensions_mut() 820 820 + .insert( 821 821 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeTrack"), 822 822 + ); 742 823 self.inner.unary(req, path, codec).await 743 824 } 744 825 pub async fn like_album( 745 826 &mut self, 746 827 request: impl tonic::IntoRequest<super::LikeAlbumRequest>, 747 747 - ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status> { 748 748 - self.inner.ready().await.map_err(|e| { 749 749 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 750 750 - })?; 828 828 + ) -> std::result::Result< 829 829 + tonic::Response<super::LikeAlbumResponse>, 830 830 + tonic::Status, 831 831 + > { 832 832 + self.inner 833 833 + .ready() 834 834 + .await 835 835 + .map_err(|e| { 836 836 + tonic::Status::unknown( 837 837 + format!("Service was not ready: {}", e.into()), 838 838 + ) 839 839 + })?; 751 840 let codec = tonic::codec::ProstCodec::default(); 752 752 - let path = 753 753 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeAlbum"); 841 841 + let path = http::uri::PathAndQuery::from_static( 842 842 + "/rockbox.v1alpha1.LibraryService/LikeAlbum", 843 843 + ); 754 844 let mut req = request.into_request(); 755 755 - req.extensions_mut().insert(GrpcMethod::new( 756 756 - "rockbox.v1alpha1.LibraryService", 757 757 - "LikeAlbum", 758 758 - )); 845 845 + req.extensions_mut() 846 846 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeAlbum")); 759 847 self.inner.unary(req, path, codec).await 760 848 } 761 849 pub async fn unlike_album( 762 850 &mut self, 763 851 request: impl tonic::IntoRequest<super::UnlikeAlbumRequest>, 764 764 - ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status> 765 765 - { 766 766 - self.inner.ready().await.map_err(|e| { 767 767 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 768 768 - })?; 852 852 + ) -> std::result::Result< 853 853 + tonic::Response<super::UnlikeAlbumResponse>, 854 854 + tonic::Status, 855 855 + > { 856 856 + self.inner 857 857 + .ready() 858 858 + .await 859 859 + .map_err(|e| { 860 860 + tonic::Status::unknown( 861 861 + format!("Service was not ready: {}", e.into()), 862 862 + ) 863 863 + })?; 769 864 let codec = tonic::codec::ProstCodec::default(); 770 865 let path = http::uri::PathAndQuery::from_static( 771 866 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum", 772 867 ); 773 868 let mut req = request.into_request(); 774 774 - req.extensions_mut().insert(GrpcMethod::new( 775 775 - "rockbox.v1alpha1.LibraryService", 776 776 - "UnlikeAlbum", 777 777 - )); 869 869 + req.extensions_mut() 870 870 + .insert( 871 871 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeAlbum"), 872 872 + ); 778 873 self.inner.unary(req, path, codec).await 779 874 } 780 875 pub async fn get_liked_tracks( 781 876 &mut self, 782 877 request: impl tonic::IntoRequest<super::GetLikedTracksRequest>, 783 783 - ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status> 784 784 - { 785 785 - self.inner.ready().await.map_err(|e| { 786 786 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 787 787 - })?; 878 878 + ) -> std::result::Result< 879 879 + tonic::Response<super::GetLikedTracksResponse>, 880 880 + tonic::Status, 881 881 + > { 882 882 + self.inner 883 883 + .ready() 884 884 + .await 885 885 + .map_err(|e| { 886 886 + tonic::Status::unknown( 887 887 + format!("Service was not ready: {}", e.into()), 888 888 + ) 889 889 + })?; 788 890 let codec = tonic::codec::ProstCodec::default(); 789 891 let path = http::uri::PathAndQuery::from_static( 790 892 "/rockbox.v1alpha1.LibraryService/GetLikedTracks", 791 893 ); 792 894 let mut req = request.into_request(); 793 793 - req.extensions_mut().insert(GrpcMethod::new( 794 794 - "rockbox.v1alpha1.LibraryService", 795 795 - "GetLikedTracks", 796 796 - )); 895 895 + req.extensions_mut() 896 896 + .insert( 897 897 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedTracks"), 898 898 + ); 797 899 self.inner.unary(req, path, codec).await 798 900 } 799 901 pub async fn get_liked_albums( 800 902 &mut self, 801 903 request: impl tonic::IntoRequest<super::GetLikedAlbumsRequest>, 802 802 - ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status> 803 803 - { 804 804 - self.inner.ready().await.map_err(|e| { 805 805 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 806 806 - })?; 904 904 + ) -> std::result::Result< 905 905 + tonic::Response<super::GetLikedAlbumsResponse>, 906 906 + tonic::Status, 907 907 + > { 908 908 + self.inner 909 909 + .ready() 910 910 + .await 911 911 + .map_err(|e| { 912 912 + tonic::Status::unknown( 913 913 + format!("Service was not ready: {}", e.into()), 914 914 + ) 915 915 + })?; 807 916 let codec = tonic::codec::ProstCodec::default(); 808 917 let path = http::uri::PathAndQuery::from_static( 809 918 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums", 810 919 ); 811 920 let mut req = request.into_request(); 812 812 - req.extensions_mut().insert(GrpcMethod::new( 813 813 - "rockbox.v1alpha1.LibraryService", 814 814 - "GetLikedAlbums", 815 815 - )); 921 921 + req.extensions_mut() 922 922 + .insert( 923 923 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedAlbums"), 924 924 + ); 816 925 self.inner.unary(req, path, codec).await 817 926 } 818 927 pub async fn scan_library( 819 928 &mut self, 820 929 request: impl tonic::IntoRequest<super::ScanLibraryRequest>, 821 821 - ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status> 822 822 - { 823 823 - self.inner.ready().await.map_err(|e| { 824 824 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 825 825 - })?; 930 930 + ) -> std::result::Result< 931 931 + tonic::Response<super::ScanLibraryResponse>, 932 932 + tonic::Status, 933 933 + > { 934 934 + self.inner 935 935 + .ready() 936 936 + .await 937 937 + .map_err(|e| { 938 938 + tonic::Status::unknown( 939 939 + format!("Service was not ready: {}", e.into()), 940 940 + ) 941 941 + })?; 826 942 let codec = tonic::codec::ProstCodec::default(); 827 943 let path = http::uri::PathAndQuery::from_static( 828 944 "/rockbox.v1alpha1.LibraryService/ScanLibrary", 829 945 ); 830 946 let mut req = request.into_request(); 831 831 - req.extensions_mut().insert(GrpcMethod::new( 832 832 - "rockbox.v1alpha1.LibraryService", 833 833 - "ScanLibrary", 834 834 - )); 947 947 + req.extensions_mut() 948 948 + .insert( 949 949 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "ScanLibrary"), 950 950 + ); 835 951 self.inner.unary(req, path, codec).await 836 952 } 837 953 pub async fn search( 838 954 &mut self, 839 955 request: impl tonic::IntoRequest<super::SearchRequest>, 840 956 ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> { 841 841 - self.inner.ready().await.map_err(|e| { 842 842 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 843 843 - })?; 957 957 + self.inner 958 958 + .ready() 959 959 + .await 960 960 + .map_err(|e| { 961 961 + tonic::Status::unknown( 962 962 + format!("Service was not ready: {}", e.into()), 963 963 + ) 964 964 + })?; 844 965 let codec = tonic::codec::ProstCodec::default(); 845 845 - let path = 846 846 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/Search"); 966 966 + let path = http::uri::PathAndQuery::from_static( 967 967 + "/rockbox.v1alpha1.LibraryService/Search", 968 968 + ); 847 969 let mut req = request.into_request(); 848 970 req.extensions_mut() 849 971 .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "Search")); ··· 858 980 dead_code, 859 981 missing_docs, 860 982 clippy::wildcard_imports, 861 861 - clippy::let_unit_value 983 983 + clippy::let_unit_value, 862 984 )] 863 985 use tonic::codegen::*; 864 986 /// Generated trait containing gRPC methods that should be implemented for use with LibraryServiceServer. ··· 867 989 async fn get_albums( 868 990 &self, 869 991 request: tonic::Request<super::GetAlbumsRequest>, 870 870 - ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status>; 992 992 + ) -> std::result::Result< 993 993 + tonic::Response<super::GetAlbumsResponse>, 994 994 + tonic::Status, 995 995 + >; 871 996 async fn get_artists( 872 997 &self, 873 998 request: tonic::Request<super::GetArtistsRequest>, 874 874 - ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status>; 999 999 + ) -> std::result::Result< 1000 1000 + tonic::Response<super::GetArtistsResponse>, 1001 1001 + tonic::Status, 1002 1002 + >; 875 1003 async fn get_tracks( 876 1004 &self, 877 1005 request: tonic::Request<super::GetTracksRequest>, 878 878 - ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status>; 1006 1006 + ) -> std::result::Result< 1007 1007 + tonic::Response<super::GetTracksResponse>, 1008 1008 + tonic::Status, 1009 1009 + >; 879 1010 async fn get_album( 880 1011 &self, 881 1012 request: tonic::Request<super::GetAlbumRequest>, 882 882 - ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status>; 1013 1013 + ) -> std::result::Result< 1014 1014 + tonic::Response<super::GetAlbumResponse>, 1015 1015 + tonic::Status, 1016 1016 + >; 883 1017 async fn get_artist( 884 1018 &self, 885 1019 request: tonic::Request<super::GetArtistRequest>, 886 886 - ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status>; 1020 1020 + ) -> std::result::Result< 1021 1021 + tonic::Response<super::GetArtistResponse>, 1022 1022 + tonic::Status, 1023 1023 + >; 887 1024 async fn get_track( 888 1025 &self, 889 1026 request: tonic::Request<super::GetTrackRequest>, 890 890 - ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status>; 1027 1027 + ) -> std::result::Result< 1028 1028 + tonic::Response<super::GetTrackResponse>, 1029 1029 + tonic::Status, 1030 1030 + >; 891 1031 async fn like_track( 892 1032 &self, 893 1033 request: tonic::Request<super::LikeTrackRequest>, 894 894 - ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status>; 1034 1034 + ) -> std::result::Result< 1035 1035 + tonic::Response<super::LikeTrackResponse>, 1036 1036 + tonic::Status, 1037 1037 + >; 895 1038 async fn unlike_track( 896 1039 &self, 897 1040 request: tonic::Request<super::UnlikeTrackRequest>, 898 898 - ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status>; 1041 1041 + ) -> std::result::Result< 1042 1042 + tonic::Response<super::UnlikeTrackResponse>, 1043 1043 + tonic::Status, 1044 1044 + >; 899 1045 async fn like_album( 900 1046 &self, 901 1047 request: tonic::Request<super::LikeAlbumRequest>, 902 902 - ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status>; 1048 1048 + ) -> std::result::Result< 1049 1049 + tonic::Response<super::LikeAlbumResponse>, 1050 1050 + tonic::Status, 1051 1051 + >; 903 1052 async fn unlike_album( 904 1053 &self, 905 1054 request: tonic::Request<super::UnlikeAlbumRequest>, 906 906 - ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status>; 1055 1055 + ) -> std::result::Result< 1056 1056 + tonic::Response<super::UnlikeAlbumResponse>, 1057 1057 + tonic::Status, 1058 1058 + >; 907 1059 async fn get_liked_tracks( 908 1060 &self, 909 1061 request: tonic::Request<super::GetLikedTracksRequest>, 910 910 - ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status>; 1062 1062 + ) -> std::result::Result< 1063 1063 + tonic::Response<super::GetLikedTracksResponse>, 1064 1064 + tonic::Status, 1065 1065 + >; 911 1066 async fn get_liked_albums( 912 1067 &self, 913 1068 request: tonic::Request<super::GetLikedAlbumsRequest>, 914 914 - ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status>; 1069 1069 + ) -> std::result::Result< 1070 1070 + tonic::Response<super::GetLikedAlbumsResponse>, 1071 1071 + tonic::Status, 1072 1072 + >; 915 1073 async fn scan_library( 916 1074 &self, 917 1075 request: tonic::Request<super::ScanLibraryRequest>, 918 918 - ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>; 1076 1076 + ) -> std::result::Result< 1077 1077 + tonic::Response<super::ScanLibraryResponse>, 1078 1078 + tonic::Status, 1079 1079 + >; 919 1080 async fn search( 920 1081 &self, 921 1082 request: tonic::Request<super::SearchRequest>, ··· 942 1103 max_encoding_message_size: None, 943 1104 } 944 1105 } 945 945 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1106 1106 + pub fn with_interceptor<F>( 1107 1107 + inner: T, 1108 1108 + interceptor: F, 1109 1109 + ) -> InterceptedService<Self, F> 946 1110 where 947 1111 F: tonic::service::Interceptor, 948 1112 { ··· 997 1161 "/rockbox.v1alpha1.LibraryService/GetAlbums" => { 998 1162 #[allow(non_camel_case_types)] 999 1163 struct GetAlbumsSvc<T: LibraryService>(pub Arc<T>); 1000 1000 - impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumsRequest> for GetAlbumsSvc<T> { 1164 1164 + impl< 1165 1165 + T: LibraryService, 1166 1166 + > tonic::server::UnaryService<super::GetAlbumsRequest> 1167 1167 + for GetAlbumsSvc<T> { 1001 1168 type Response = super::GetAlbumsResponse; 1002 1002 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1169 1169 + type Future = BoxFuture< 1170 1170 + tonic::Response<Self::Response>, 1171 1171 + tonic::Status, 1172 1172 + >; 1003 1173 fn call( 1004 1174 &mut self, 1005 1175 request: tonic::Request<super::GetAlbumsRequest>, ··· 1036 1206 "/rockbox.v1alpha1.LibraryService/GetArtists" => { 1037 1207 #[allow(non_camel_case_types)] 1038 1208 struct GetArtistsSvc<T: LibraryService>(pub Arc<T>); 1039 1039 - impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistsRequest> for GetArtistsSvc<T> { 1209 1209 + impl< 1210 1210 + T: LibraryService, 1211 1211 + > tonic::server::UnaryService<super::GetArtistsRequest> 1212 1212 + for GetArtistsSvc<T> { 1040 1213 type Response = super::GetArtistsResponse; 1041 1041 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1214 1214 + type Future = BoxFuture< 1215 1215 + tonic::Response<Self::Response>, 1216 1216 + tonic::Status, 1217 1217 + >; 1042 1218 fn call( 1043 1219 &mut self, 1044 1220 request: tonic::Request<super::GetArtistsRequest>, ··· 1075 1251 "/rockbox.v1alpha1.LibraryService/GetTracks" => { 1076 1252 #[allow(non_camel_case_types)] 1077 1253 struct GetTracksSvc<T: LibraryService>(pub Arc<T>); 1078 1078 - impl<T: LibraryService> tonic::server::UnaryService<super::GetTracksRequest> for GetTracksSvc<T> { 1254 1254 + impl< 1255 1255 + T: LibraryService, 1256 1256 + > tonic::server::UnaryService<super::GetTracksRequest> 1257 1257 + for GetTracksSvc<T> { 1079 1258 type Response = super::GetTracksResponse; 1080 1080 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1259 1259 + type Future = BoxFuture< 1260 1260 + tonic::Response<Self::Response>, 1261 1261 + tonic::Status, 1262 1262 + >; 1081 1263 fn call( 1082 1264 &mut self, 1083 1265 request: tonic::Request<super::GetTracksRequest>, ··· 1114 1296 "/rockbox.v1alpha1.LibraryService/GetAlbum" => { 1115 1297 #[allow(non_camel_case_types)] 1116 1298 struct GetAlbumSvc<T: LibraryService>(pub Arc<T>); 1117 1117 - impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumRequest> for GetAlbumSvc<T> { 1299 1299 + impl< 1300 1300 + T: LibraryService, 1301 1301 + > tonic::server::UnaryService<super::GetAlbumRequest> 1302 1302 + for GetAlbumSvc<T> { 1118 1303 type Response = super::GetAlbumResponse; 1119 1119 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1304 1304 + type Future = BoxFuture< 1305 1305 + tonic::Response<Self::Response>, 1306 1306 + tonic::Status, 1307 1307 + >; 1120 1308 fn call( 1121 1309 &mut self, 1122 1310 request: tonic::Request<super::GetAlbumRequest>, ··· 1153 1341 "/rockbox.v1alpha1.LibraryService/GetArtist" => { 1154 1342 #[allow(non_camel_case_types)] 1155 1343 struct GetArtistSvc<T: LibraryService>(pub Arc<T>); 1156 1156 - impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistRequest> for GetArtistSvc<T> { 1344 1344 + impl< 1345 1345 + T: LibraryService, 1346 1346 + > tonic::server::UnaryService<super::GetArtistRequest> 1347 1347 + for GetArtistSvc<T> { 1157 1348 type Response = super::GetArtistResponse; 1158 1158 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1349 1349 + type Future = BoxFuture< 1350 1350 + tonic::Response<Self::Response>, 1351 1351 + tonic::Status, 1352 1352 + >; 1159 1353 fn call( 1160 1354 &mut self, 1161 1355 request: tonic::Request<super::GetArtistRequest>, ··· 1192 1386 "/rockbox.v1alpha1.LibraryService/GetTrack" => { 1193 1387 #[allow(non_camel_case_types)] 1194 1388 struct GetTrackSvc<T: LibraryService>(pub Arc<T>); 1195 1195 - impl<T: LibraryService> tonic::server::UnaryService<super::GetTrackRequest> for GetTrackSvc<T> { 1389 1389 + impl< 1390 1390 + T: LibraryService, 1391 1391 + > tonic::server::UnaryService<super::GetTrackRequest> 1392 1392 + for GetTrackSvc<T> { 1196 1393 type Response = super::GetTrackResponse; 1197 1197 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1394 1394 + type Future = BoxFuture< 1395 1395 + tonic::Response<Self::Response>, 1396 1396 + tonic::Status, 1397 1397 + >; 1198 1398 fn call( 1199 1399 &mut self, 1200 1400 request: tonic::Request<super::GetTrackRequest>, ··· 1231 1431 "/rockbox.v1alpha1.LibraryService/LikeTrack" => { 1232 1432 #[allow(non_camel_case_types)] 1233 1433 struct LikeTrackSvc<T: LibraryService>(pub Arc<T>); 1234 1234 - impl<T: LibraryService> tonic::server::UnaryService<super::LikeTrackRequest> for LikeTrackSvc<T> { 1434 1434 + impl< 1435 1435 + T: LibraryService, 1436 1436 + > tonic::server::UnaryService<super::LikeTrackRequest> 1437 1437 + for LikeTrackSvc<T> { 1235 1438 type Response = super::LikeTrackResponse; 1236 1236 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1439 1439 + type Future = BoxFuture< 1440 1440 + tonic::Response<Self::Response>, 1441 1441 + tonic::Status, 1442 1442 + >; 1237 1443 fn call( 1238 1444 &mut self, 1239 1445 request: tonic::Request<super::LikeTrackRequest>, ··· 1270 1476 "/rockbox.v1alpha1.LibraryService/UnlikeTrack" => { 1271 1477 #[allow(non_camel_case_types)] 1272 1478 struct UnlikeTrackSvc<T: LibraryService>(pub Arc<T>); 1273 1273 - impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeTrackRequest> 1274 1274 - for UnlikeTrackSvc<T> 1275 1275 - { 1479 1479 + impl< 1480 1480 + T: LibraryService, 1481 1481 + > tonic::server::UnaryService<super::UnlikeTrackRequest> 1482 1482 + for UnlikeTrackSvc<T> { 1276 1483 type Response = super::UnlikeTrackResponse; 1277 1277 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1484 1484 + type Future = BoxFuture< 1485 1485 + tonic::Response<Self::Response>, 1486 1486 + tonic::Status, 1487 1487 + >; 1278 1488 fn call( 1279 1489 &mut self, 1280 1490 request: tonic::Request<super::UnlikeTrackRequest>, ··· 1311 1521 "/rockbox.v1alpha1.LibraryService/LikeAlbum" => { 1312 1522 #[allow(non_camel_case_types)] 1313 1523 struct LikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1314 1314 - impl<T: LibraryService> tonic::server::UnaryService<super::LikeAlbumRequest> for LikeAlbumSvc<T> { 1524 1524 + impl< 1525 1525 + T: LibraryService, 1526 1526 + > tonic::server::UnaryService<super::LikeAlbumRequest> 1527 1527 + for LikeAlbumSvc<T> { 1315 1528 type Response = super::LikeAlbumResponse; 1316 1316 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1529 1529 + type Future = BoxFuture< 1530 1530 + tonic::Response<Self::Response>, 1531 1531 + tonic::Status, 1532 1532 + >; 1317 1533 fn call( 1318 1534 &mut self, 1319 1535 request: tonic::Request<super::LikeAlbumRequest>, ··· 1350 1566 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum" => { 1351 1567 #[allow(non_camel_case_types)] 1352 1568 struct UnlikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1353 1353 - impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeAlbumRequest> 1354 1354 - for UnlikeAlbumSvc<T> 1355 1355 - { 1569 1569 + impl< 1570 1570 + T: LibraryService, 1571 1571 + > tonic::server::UnaryService<super::UnlikeAlbumRequest> 1572 1572 + for UnlikeAlbumSvc<T> { 1356 1573 type Response = super::UnlikeAlbumResponse; 1357 1357 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1574 1574 + type Future = BoxFuture< 1575 1575 + tonic::Response<Self::Response>, 1576 1576 + tonic::Status, 1577 1577 + >; 1358 1578 fn call( 1359 1579 &mut self, 1360 1580 request: tonic::Request<super::UnlikeAlbumRequest>, ··· 1391 1611 "/rockbox.v1alpha1.LibraryService/GetLikedTracks" => { 1392 1612 #[allow(non_camel_case_types)] 1393 1613 struct GetLikedTracksSvc<T: LibraryService>(pub Arc<T>); 1394 1394 - impl<T: LibraryService> 1395 1395 - tonic::server::UnaryService<super::GetLikedTracksRequest> 1396 1396 - for GetLikedTracksSvc<T> 1397 1397 - { 1614 1614 + impl< 1615 1615 + T: LibraryService, 1616 1616 + > tonic::server::UnaryService<super::GetLikedTracksRequest> 1617 1617 + for GetLikedTracksSvc<T> { 1398 1618 type Response = super::GetLikedTracksResponse; 1399 1399 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1619 1619 + type Future = BoxFuture< 1620 1620 + tonic::Response<Self::Response>, 1621 1621 + tonic::Status, 1622 1622 + >; 1400 1623 fn call( 1401 1624 &mut self, 1402 1625 request: tonic::Request<super::GetLikedTracksRequest>, 1403 1626 ) -> Self::Future { 1404 1627 let inner = Arc::clone(&self.0); 1405 1628 let fut = async move { 1406 1406 - <T as LibraryService>::get_liked_tracks(&inner, request).await 1629 1629 + <T as LibraryService>::get_liked_tracks(&inner, request) 1630 1630 + .await 1407 1631 }; 1408 1632 Box::pin(fut) 1409 1633 } ··· 1433 1657 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums" => { 1434 1658 #[allow(non_camel_case_types)] 1435 1659 struct GetLikedAlbumsSvc<T: LibraryService>(pub Arc<T>); 1436 1436 - impl<T: LibraryService> 1437 1437 - tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1438 1438 - for GetLikedAlbumsSvc<T> 1439 1439 - { 1660 1660 + impl< 1661 1661 + T: LibraryService, 1662 1662 + > tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1663 1663 + for GetLikedAlbumsSvc<T> { 1440 1664 type Response = super::GetLikedAlbumsResponse; 1441 1441 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1665 1665 + type Future = BoxFuture< 1666 1666 + tonic::Response<Self::Response>, 1667 1667 + tonic::Status, 1668 1668 + >; 1442 1669 fn call( 1443 1670 &mut self, 1444 1671 request: tonic::Request<super::GetLikedAlbumsRequest>, 1445 1672 ) -> Self::Future { 1446 1673 let inner = Arc::clone(&self.0); 1447 1674 let fut = async move { 1448 1448 - <T as LibraryService>::get_liked_albums(&inner, request).await 1675 1675 + <T as LibraryService>::get_liked_albums(&inner, request) 1676 1676 + .await 1449 1677 }; 1450 1678 Box::pin(fut) 1451 1679 } ··· 1475 1703 "/rockbox.v1alpha1.LibraryService/ScanLibrary" => { 1476 1704 #[allow(non_camel_case_types)] 1477 1705 struct ScanLibrarySvc<T: LibraryService>(pub Arc<T>); 1478 1478 - impl<T: LibraryService> tonic::server::UnaryService<super::ScanLibraryRequest> 1479 1479 - for ScanLibrarySvc<T> 1480 1480 - { 1706 1706 + impl< 1707 1707 + T: LibraryService, 1708 1708 + > tonic::server::UnaryService<super::ScanLibraryRequest> 1709 1709 + for ScanLibrarySvc<T> { 1481 1710 type Response = super::ScanLibraryResponse; 1482 1482 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1711 1711 + type Future = BoxFuture< 1712 1712 + tonic::Response<Self::Response>, 1713 1713 + tonic::Status, 1714 1714 + >; 1483 1715 fn call( 1484 1716 &mut self, 1485 1717 request: tonic::Request<super::ScanLibraryRequest>, ··· 1516 1748 "/rockbox.v1alpha1.LibraryService/Search" => { 1517 1749 #[allow(non_camel_case_types)] 1518 1750 struct SearchSvc<T: LibraryService>(pub Arc<T>); 1519 1519 - impl<T: LibraryService> tonic::server::UnaryService<super::SearchRequest> for SearchSvc<T> { 1751 1751 + impl< 1752 1752 + T: LibraryService, 1753 1753 + > tonic::server::UnaryService<super::SearchRequest> 1754 1754 + for SearchSvc<T> { 1520 1755 type Response = super::SearchResponse; 1521 1521 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1756 1756 + type Future = BoxFuture< 1757 1757 + tonic::Response<Self::Response>, 1758 1758 + tonic::Status, 1759 1759 + >; 1522 1760 fn call( 1523 1761 &mut self, 1524 1762 request: tonic::Request<super::SearchRequest>, 1525 1763 ) -> Self::Future { 1526 1764 let inner = Arc::clone(&self.0); 1527 1527 - let fut = 1528 1528 - async move { <T as LibraryService>::search(&inner, request).await }; 1765 1765 + let fut = async move { 1766 1766 + <T as LibraryService>::search(&inner, request).await 1767 1767 + }; 1529 1768 Box::pin(fut) 1530 1769 } 1531 1770 } ··· 1551 1790 }; 1552 1791 Box::pin(fut) 1553 1792 } 1554 1554 - _ => Box::pin(async move { 1555 1555 - let mut response = http::Response::new(empty_body()); 1556 1556 - let headers = response.headers_mut(); 1557 1557 - headers.insert( 1558 1558 - tonic::Status::GRPC_STATUS, 1559 1559 - (tonic::Code::Unimplemented as i32).into(), 1560 1560 - ); 1561 1561 - headers.insert( 1562 1562 - http::header::CONTENT_TYPE, 1563 1563 - tonic::metadata::GRPC_CONTENT_TYPE, 1564 1564 - ); 1565 1565 - Ok(response) 1566 1566 - }), 1793 1793 + _ => { 1794 1794 + Box::pin(async move { 1795 1795 + let mut response = http::Response::new(empty_body()); 1796 1796 + let headers = response.headers_mut(); 1797 1797 + headers 1798 1798 + .insert( 1799 1799 + tonic::Status::GRPC_STATUS, 1800 1800 + (tonic::Code::Unimplemented as i32).into(), 1801 1801 + ); 1802 1802 + headers 1803 1803 + .insert( 1804 1804 + http::header::CONTENT_TYPE, 1805 1805 + tonic::metadata::GRPC_CONTENT_TYPE, 1806 1806 + ); 1807 1807 + Ok(response) 1808 1808 + }) 1809 1809 + } 1567 1810 } 1568 1811 } 1569 1812 } ··· 1592 1835 dead_code, 1593 1836 missing_docs, 1594 1837 clippy::wildcard_imports, 1595 1595 - clippy::let_unit_value 1838 1838 + clippy::let_unit_value, 1596 1839 )] 1597 1597 - use tonic::codegen::http::Uri; 1598 1840 use tonic::codegen::*; 1841 1841 + use tonic::codegen::http::Uri; 1599 1842 #[derive(Debug, Clone)] 1600 1843 pub struct MetadataServiceClient<T> { 1601 1844 inner: tonic::client::Grpc<T>, ··· 1639 1882 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 1640 1883 >, 1641 1884 >, 1642 1642 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 1643 1643 - Into<StdError> + std::marker::Send + std::marker::Sync, 1885 1885 + <T as tonic::codegen::Service< 1886 1886 + http::Request<tonic::body::BoxBody>, 1887 1887 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 1644 1888 { 1645 1889 MetadataServiceClient::new(InterceptedService::new(inner, interceptor)) 1646 1890 } ··· 1684 1928 dead_code, 1685 1929 missing_docs, 1686 1930 clippy::wildcard_imports, 1687 1687 - clippy::let_unit_value 1931 1931 + clippy::let_unit_value, 1688 1932 )] 1689 1933 use tonic::codegen::*; 1690 1934 /// Generated trait containing gRPC methods that should be implemented for use with MetadataServiceServer. ··· 1711 1955 max_encoding_message_size: None, 1712 1956 } 1713 1957 } 1714 1714 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1958 1958 + pub fn with_interceptor<F>( 1959 1959 + inner: T, 1960 1960 + interceptor: F, 1961 1961 + ) -> InterceptedService<Self, F> 1715 1962 where 1716 1963 F: tonic::service::Interceptor, 1717 1964 { ··· 1763 2010 } 1764 2011 fn call(&mut self, req: http::Request<B>) -> Self::Future { 1765 2012 match req.uri().path() { 1766 1766 - _ => Box::pin(async move { 1767 1767 - let mut response = http::Response::new(empty_body()); 1768 1768 - let headers = response.headers_mut(); 1769 1769 - headers.insert( 1770 1770 - tonic::Status::GRPC_STATUS, 1771 1771 - (tonic::Code::Unimplemented as i32).into(), 1772 1772 - ); 1773 1773 - headers.insert( 1774 1774 - http::header::CONTENT_TYPE, 1775 1775 - tonic::metadata::GRPC_CONTENT_TYPE, 1776 1776 - ); 1777 1777 - Ok(response) 1778 1778 - }), 2013 2013 + _ => { 2014 2014 + Box::pin(async move { 2015 2015 + let mut response = http::Response::new(empty_body()); 2016 2016 + let headers = response.headers_mut(); 2017 2017 + headers 2018 2018 + .insert( 2019 2019 + tonic::Status::GRPC_STATUS, 2020 2020 + (tonic::Code::Unimplemented as i32).into(), 2021 2021 + ); 2022 2022 + headers 2023 2023 + .insert( 2024 2024 + http::header::CONTENT_TYPE, 2025 2025 + tonic::metadata::GRPC_CONTENT_TYPE, 2026 2026 + ); 2027 2027 + Ok(response) 2028 2028 + }) 2029 2029 + } 1779 2030 } 1780 2031 } 1781 2032 } ··· 2048 2299 dead_code, 2049 2300 missing_docs, 2050 2301 clippy::wildcard_imports, 2051 2051 - clippy::let_unit_value 2302 2302 + clippy::let_unit_value, 2052 2303 )] 2053 2053 - use tonic::codegen::http::Uri; 2054 2304 use tonic::codegen::*; 2305 2305 + use tonic::codegen::http::Uri; 2055 2306 #[derive(Debug, Clone)] 2056 2307 pub struct PlaybackServiceClient<T> { 2057 2308 inner: tonic::client::Grpc<T>, ··· 2095 2346 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 2096 2347 >, 2097 2348 >, 2098 2098 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 2099 2099 - Into<StdError> + std::marker::Send + std::marker::Sync, 2349 2349 + <T as tonic::codegen::Service< 2350 2350 + http::Request<tonic::body::BoxBody>, 2351 2351 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 2100 2352 { 2101 2353 PlaybackServiceClient::new(InterceptedService::new(inner, interceptor)) 2102 2354 } ··· 2135 2387 &mut self, 2136 2388 request: impl tonic::IntoRequest<super::PlayRequest>, 2137 2389 ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> { 2138 2138 - self.inner.ready().await.map_err(|e| { 2139 2139 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2140 2140 - })?; 2390 2390 + self.inner 2391 2391 + .ready() 2392 2392 + .await 2393 2393 + .map_err(|e| { 2394 2394 + tonic::Status::unknown( 2395 2395 + format!("Service was not ready: {}", e.into()), 2396 2396 + ) 2397 2397 + })?; 2141 2398 let codec = tonic::codec::ProstCodec::default(); 2142 2142 - let path = 2143 2143 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Play"); 2399 2399 + let path = http::uri::PathAndQuery::from_static( 2400 2400 + "/rockbox.v1alpha1.PlaybackService/Play", 2401 2401 + ); 2144 2402 let mut req = request.into_request(); 2145 2403 req.extensions_mut() 2146 2404 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Play")); ··· 2150 2408 &mut self, 2151 2409 request: impl tonic::IntoRequest<super::PauseRequest>, 2152 2410 ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> { 2153 2153 - self.inner.ready().await.map_err(|e| { 2154 2154 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2155 2155 - })?; 2411 2411 + self.inner 2412 2412 + .ready() 2413 2413 + .await 2414 2414 + .map_err(|e| { 2415 2415 + tonic::Status::unknown( 2416 2416 + format!("Service was not ready: {}", e.into()), 2417 2417 + ) 2418 2418 + })?; 2156 2419 let codec = tonic::codec::ProstCodec::default(); 2157 2157 - let path = 2158 2158 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Pause"); 2420 2420 + let path = http::uri::PathAndQuery::from_static( 2421 2421 + "/rockbox.v1alpha1.PlaybackService/Pause", 2422 2422 + ); 2159 2423 let mut req = request.into_request(); 2160 2424 req.extensions_mut() 2161 2425 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Pause")); ··· 2164 2428 pub async fn play_or_pause( 2165 2429 &mut self, 2166 2430 request: impl tonic::IntoRequest<super::PlayOrPauseRequest>, 2167 2167 - ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status> 2168 2168 - { 2169 2169 - self.inner.ready().await.map_err(|e| { 2170 2170 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2171 2171 - })?; 2431 2431 + ) -> std::result::Result< 2432 2432 + tonic::Response<super::PlayOrPauseResponse>, 2433 2433 + tonic::Status, 2434 2434 + > { 2435 2435 + self.inner 2436 2436 + .ready() 2437 2437 + .await 2438 2438 + .map_err(|e| { 2439 2439 + tonic::Status::unknown( 2440 2440 + format!("Service was not ready: {}", e.into()), 2441 2441 + ) 2442 2442 + })?; 2172 2443 let codec = tonic::codec::ProstCodec::default(); 2173 2444 let path = http::uri::PathAndQuery::from_static( 2174 2445 "/rockbox.v1alpha1.PlaybackService/PlayOrPause", 2175 2446 ); 2176 2447 let mut req = request.into_request(); 2177 2177 - req.extensions_mut().insert(GrpcMethod::new( 2178 2178 - "rockbox.v1alpha1.PlaybackService", 2179 2179 - "PlayOrPause", 2180 2180 - )); 2448 2448 + req.extensions_mut() 2449 2449 + .insert( 2450 2450 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayOrPause"), 2451 2451 + ); 2181 2452 self.inner.unary(req, path, codec).await 2182 2453 } 2183 2454 pub async fn resume( 2184 2455 &mut self, 2185 2456 request: impl tonic::IntoRequest<super::ResumeRequest>, 2186 2457 ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> { 2187 2187 - self.inner.ready().await.map_err(|e| { 2188 2188 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2189 2189 - })?; 2458 2458 + self.inner 2459 2459 + .ready() 2460 2460 + .await 2461 2461 + .map_err(|e| { 2462 2462 + tonic::Status::unknown( 2463 2463 + format!("Service was not ready: {}", e.into()), 2464 2464 + ) 2465 2465 + })?; 2190 2466 let codec = tonic::codec::ProstCodec::default(); 2191 2191 - let path = 2192 2192 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Resume"); 2467 2467 + let path = http::uri::PathAndQuery::from_static( 2468 2468 + "/rockbox.v1alpha1.PlaybackService/Resume", 2469 2469 + ); 2193 2470 let mut req = request.into_request(); 2194 2194 - req.extensions_mut().insert(GrpcMethod::new( 2195 2195 - "rockbox.v1alpha1.PlaybackService", 2196 2196 - "Resume", 2197 2197 - )); 2471 2471 + req.extensions_mut() 2472 2472 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Resume")); 2198 2473 self.inner.unary(req, path, codec).await 2199 2474 } 2200 2475 pub async fn next( 2201 2476 &mut self, 2202 2477 request: impl tonic::IntoRequest<super::NextRequest>, 2203 2478 ) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status> { 2204 2204 - self.inner.ready().await.map_err(|e| { 2205 2205 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2206 2206 - })?; 2479 2479 + self.inner 2480 2480 + .ready() 2481 2481 + .await 2482 2482 + .map_err(|e| { 2483 2483 + tonic::Status::unknown( 2484 2484 + format!("Service was not ready: {}", e.into()), 2485 2485 + ) 2486 2486 + })?; 2207 2487 let codec = tonic::codec::ProstCodec::default(); 2208 2208 - let path = 2209 2209 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Next"); 2488 2488 + let path = http::uri::PathAndQuery::from_static( 2489 2489 + "/rockbox.v1alpha1.PlaybackService/Next", 2490 2490 + ); 2210 2491 let mut req = request.into_request(); 2211 2492 req.extensions_mut() 2212 2493 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Next")); ··· 2215 2496 pub async fn previous( 2216 2497 &mut self, 2217 2498 request: impl tonic::IntoRequest<super::PreviousRequest>, 2218 2218 - ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status> { 2219 2219 - self.inner.ready().await.map_err(|e| { 2220 2220 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2221 2221 - })?; 2499 2499 + ) -> std::result::Result< 2500 2500 + tonic::Response<super::PreviousResponse>, 2501 2501 + tonic::Status, 2502 2502 + > { 2503 2503 + self.inner 2504 2504 + .ready() 2505 2505 + .await 2506 2506 + .map_err(|e| { 2507 2507 + tonic::Status::unknown( 2508 2508 + format!("Service was not ready: {}", e.into()), 2509 2509 + ) 2510 2510 + })?; 2222 2511 let codec = tonic::codec::ProstCodec::default(); 2223 2223 - let path = 2224 2224 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Previous"); 2512 2512 + let path = http::uri::PathAndQuery::from_static( 2513 2513 + "/rockbox.v1alpha1.PlaybackService/Previous", 2514 2514 + ); 2225 2515 let mut req = request.into_request(); 2226 2226 - req.extensions_mut().insert(GrpcMethod::new( 2227 2227 - "rockbox.v1alpha1.PlaybackService", 2228 2228 - "Previous", 2229 2229 - )); 2516 2516 + req.extensions_mut() 2517 2517 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Previous")); 2230 2518 self.inner.unary(req, path, codec).await 2231 2519 } 2232 2520 pub async fn fast_forward_rewind( 2233 2521 &mut self, 2234 2522 request: impl tonic::IntoRequest<super::FastForwardRewindRequest>, 2235 2235 - ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status> 2236 2236 - { 2237 2237 - self.inner.ready().await.map_err(|e| { 2238 2238 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2239 2239 - })?; 2523 2523 + ) -> std::result::Result< 2524 2524 + tonic::Response<super::FastForwardRewindResponse>, 2525 2525 + tonic::Status, 2526 2526 + > { 2527 2527 + self.inner 2528 2528 + .ready() 2529 2529 + .await 2530 2530 + .map_err(|e| { 2531 2531 + tonic::Status::unknown( 2532 2532 + format!("Service was not ready: {}", e.into()), 2533 2533 + ) 2534 2534 + })?; 2240 2535 let codec = tonic::codec::ProstCodec::default(); 2241 2536 let path = http::uri::PathAndQuery::from_static( 2242 2537 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind", 2243 2538 ); 2244 2539 let mut req = request.into_request(); 2245 2245 - req.extensions_mut().insert(GrpcMethod::new( 2246 2246 - "rockbox.v1alpha1.PlaybackService", 2247 2247 - "FastForwardRewind", 2248 2248 - )); 2540 2540 + req.extensions_mut() 2541 2541 + .insert( 2542 2542 + GrpcMethod::new( 2543 2543 + "rockbox.v1alpha1.PlaybackService", 2544 2544 + "FastForwardRewind", 2545 2545 + ), 2546 2546 + ); 2249 2547 self.inner.unary(req, path, codec).await 2250 2548 } 2251 2549 pub async fn status( 2252 2550 &mut self, 2253 2551 request: impl tonic::IntoRequest<super::StatusRequest>, 2254 2552 ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> { 2255 2255 - self.inner.ready().await.map_err(|e| { 2256 2256 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2257 2257 - })?; 2553 2553 + self.inner 2554 2554 + .ready() 2555 2555 + .await 2556 2556 + .map_err(|e| { 2557 2557 + tonic::Status::unknown( 2558 2558 + format!("Service was not ready: {}", e.into()), 2559 2559 + ) 2560 2560 + })?; 2258 2561 let codec = tonic::codec::ProstCodec::default(); 2259 2259 - let path = 2260 2260 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Status"); 2562 2562 + let path = http::uri::PathAndQuery::from_static( 2563 2563 + "/rockbox.v1alpha1.PlaybackService/Status", 2564 2564 + ); 2261 2565 let mut req = request.into_request(); 2262 2262 - req.extensions_mut().insert(GrpcMethod::new( 2263 2263 - "rockbox.v1alpha1.PlaybackService", 2264 2264 - "Status", 2265 2265 - )); 2566 2566 + req.extensions_mut() 2567 2567 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Status")); 2266 2568 self.inner.unary(req, path, codec).await 2267 2569 } 2268 2570 pub async fn current_track( 2269 2571 &mut self, 2270 2572 request: impl tonic::IntoRequest<super::CurrentTrackRequest>, 2271 2271 - ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status> 2272 2272 - { 2273 2273 - self.inner.ready().await.map_err(|e| { 2274 2274 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2275 2275 - })?; 2573 2573 + ) -> std::result::Result< 2574 2574 + tonic::Response<super::CurrentTrackResponse>, 2575 2575 + tonic::Status, 2576 2576 + > { 2577 2577 + self.inner 2578 2578 + .ready() 2579 2579 + .await 2580 2580 + .map_err(|e| { 2581 2581 + tonic::Status::unknown( 2582 2582 + format!("Service was not ready: {}", e.into()), 2583 2583 + ) 2584 2584 + })?; 2276 2585 let codec = tonic::codec::ProstCodec::default(); 2277 2586 let path = http::uri::PathAndQuery::from_static( 2278 2587 "/rockbox.v1alpha1.PlaybackService/CurrentTrack", 2279 2588 ); 2280 2589 let mut req = request.into_request(); 2281 2281 - req.extensions_mut().insert(GrpcMethod::new( 2282 2282 - "rockbox.v1alpha1.PlaybackService", 2283 2283 - "CurrentTrack", 2284 2284 - )); 2590 2590 + req.extensions_mut() 2591 2591 + .insert( 2592 2592 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "CurrentTrack"), 2593 2593 + ); 2285 2594 self.inner.unary(req, path, codec).await 2286 2595 } 2287 2596 pub async fn next_track( 2288 2597 &mut self, 2289 2598 request: impl tonic::IntoRequest<super::NextTrackRequest>, 2290 2290 - ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status> { 2291 2291 - self.inner.ready().await.map_err(|e| { 2292 2292 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2293 2293 - })?; 2599 2599 + ) -> std::result::Result< 2600 2600 + tonic::Response<super::NextTrackResponse>, 2601 2601 + tonic::Status, 2602 2602 + > { 2603 2603 + self.inner 2604 2604 + .ready() 2605 2605 + .await 2606 2606 + .map_err(|e| { 2607 2607 + tonic::Status::unknown( 2608 2608 + format!("Service was not ready: {}", e.into()), 2609 2609 + ) 2610 2610 + })?; 2294 2611 let codec = tonic::codec::ProstCodec::default(); 2295 2295 - let path = 2296 2296 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/NextTrack"); 2612 2612 + let path = http::uri::PathAndQuery::from_static( 2613 2613 + "/rockbox.v1alpha1.PlaybackService/NextTrack", 2614 2614 + ); 2297 2615 let mut req = request.into_request(); 2298 2298 - req.extensions_mut().insert(GrpcMethod::new( 2299 2299 - "rockbox.v1alpha1.PlaybackService", 2300 2300 - "NextTrack", 2301 2301 - )); 2616 2616 + req.extensions_mut() 2617 2617 + .insert( 2618 2618 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "NextTrack"), 2619 2619 + ); 2302 2620 self.inner.unary(req, path, codec).await 2303 2621 } 2304 2622 pub async fn flush_and_reload_tracks( 2305 2623 &mut self, 2306 2624 request: impl tonic::IntoRequest<super::FlushAndReloadTracksRequest>, 2307 2307 - ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status> 2308 2308 - { 2309 2309 - self.inner.ready().await.map_err(|e| { 2310 2310 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2311 2311 - })?; 2625 2625 + ) -> std::result::Result< 2626 2626 + tonic::Response<super::FlushAndReloadTracksResponse>, 2627 2627 + tonic::Status, 2628 2628 + > { 2629 2629 + self.inner 2630 2630 + .ready() 2631 2631 + .await 2632 2632 + .map_err(|e| { 2633 2633 + tonic::Status::unknown( 2634 2634 + format!("Service was not ready: {}", e.into()), 2635 2635 + ) 2636 2636 + })?; 2312 2637 let codec = tonic::codec::ProstCodec::default(); 2313 2638 let path = http::uri::PathAndQuery::from_static( 2314 2639 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks", 2315 2640 ); 2316 2641 let mut req = request.into_request(); 2317 2317 - req.extensions_mut().insert(GrpcMethod::new( 2318 2318 - "rockbox.v1alpha1.PlaybackService", 2319 2319 - "FlushAndReloadTracks", 2320 2320 - )); 2642 2642 + req.extensions_mut() 2643 2643 + .insert( 2644 2644 + GrpcMethod::new( 2645 2645 + "rockbox.v1alpha1.PlaybackService", 2646 2646 + "FlushAndReloadTracks", 2647 2647 + ), 2648 2648 + ); 2321 2649 self.inner.unary(req, path, codec).await 2322 2650 } 2323 2651 pub async fn get_file_position( 2324 2652 &mut self, 2325 2653 request: impl tonic::IntoRequest<super::GetFilePositionRequest>, 2326 2326 - ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status> 2327 2327 - { 2328 2328 - self.inner.ready().await.map_err(|e| { 2329 2329 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2330 2330 - })?; 2654 2654 + ) -> std::result::Result< 2655 2655 + tonic::Response<super::GetFilePositionResponse>, 2656 2656 + tonic::Status, 2657 2657 + > { 2658 2658 + self.inner 2659 2659 + .ready() 2660 2660 + .await 2661 2661 + .map_err(|e| { 2662 2662 + tonic::Status::unknown( 2663 2663 + format!("Service was not ready: {}", e.into()), 2664 2664 + ) 2665 2665 + })?; 2331 2666 let codec = tonic::codec::ProstCodec::default(); 2332 2667 let path = http::uri::PathAndQuery::from_static( 2333 2668 "/rockbox.v1alpha1.PlaybackService/GetFilePosition", 2334 2669 ); 2335 2670 let mut req = request.into_request(); 2336 2336 - req.extensions_mut().insert(GrpcMethod::new( 2337 2337 - "rockbox.v1alpha1.PlaybackService", 2338 2338 - "GetFilePosition", 2339 2339 - )); 2671 2671 + req.extensions_mut() 2672 2672 + .insert( 2673 2673 + GrpcMethod::new( 2674 2674 + "rockbox.v1alpha1.PlaybackService", 2675 2675 + "GetFilePosition", 2676 2676 + ), 2677 2677 + ); 2340 2678 self.inner.unary(req, path, codec).await 2341 2679 } 2342 2680 pub async fn hard_stop( 2343 2681 &mut self, 2344 2682 request: impl tonic::IntoRequest<super::HardStopRequest>, 2345 2345 - ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status> { 2346 2346 - self.inner.ready().await.map_err(|e| { 2347 2347 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2348 2348 - })?; 2683 2683 + ) -> std::result::Result< 2684 2684 + tonic::Response<super::HardStopResponse>, 2685 2685 + tonic::Status, 2686 2686 + > { 2687 2687 + self.inner 2688 2688 + .ready() 2689 2689 + .await 2690 2690 + .map_err(|e| { 2691 2691 + tonic::Status::unknown( 2692 2692 + format!("Service was not ready: {}", e.into()), 2693 2693 + ) 2694 2694 + })?; 2349 2695 let codec = tonic::codec::ProstCodec::default(); 2350 2350 - let path = 2351 2351 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/HardStop"); 2696 2696 + let path = http::uri::PathAndQuery::from_static( 2697 2697 + "/rockbox.v1alpha1.PlaybackService/HardStop", 2698 2698 + ); 2352 2699 let mut req = request.into_request(); 2353 2353 - req.extensions_mut().insert(GrpcMethod::new( 2354 2354 - "rockbox.v1alpha1.PlaybackService", 2355 2355 - "HardStop", 2356 2356 - )); 2700 2700 + req.extensions_mut() 2701 2701 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "HardStop")); 2357 2702 self.inner.unary(req, path, codec).await 2358 2703 } 2359 2704 pub async fn play_album( 2360 2705 &mut self, 2361 2706 request: impl tonic::IntoRequest<super::PlayAlbumRequest>, 2362 2362 - ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status> { 2363 2363 - self.inner.ready().await.map_err(|e| { 2364 2364 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2365 2365 - })?; 2707 2707 + ) -> std::result::Result< 2708 2708 + tonic::Response<super::PlayAlbumResponse>, 2709 2709 + tonic::Status, 2710 2710 + > { 2711 2711 + self.inner 2712 2712 + .ready() 2713 2713 + .await 2714 2714 + .map_err(|e| { 2715 2715 + tonic::Status::unknown( 2716 2716 + format!("Service was not ready: {}", e.into()), 2717 2717 + ) 2718 2718 + })?; 2366 2719 let codec = tonic::codec::ProstCodec::default(); 2367 2367 - let path = 2368 2368 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayAlbum"); 2720 2720 + let path = http::uri::PathAndQuery::from_static( 2721 2721 + "/rockbox.v1alpha1.PlaybackService/PlayAlbum", 2722 2722 + ); 2369 2723 let mut req = request.into_request(); 2370 2370 - req.extensions_mut().insert(GrpcMethod::new( 2371 2371 - "rockbox.v1alpha1.PlaybackService", 2372 2372 - "PlayAlbum", 2373 2373 - )); 2724 2724 + req.extensions_mut() 2725 2725 + .insert( 2726 2726 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAlbum"), 2727 2727 + ); 2374 2728 self.inner.unary(req, path, codec).await 2375 2729 } 2376 2730 pub async fn play_artist_tracks( 2377 2731 &mut self, 2378 2732 request: impl tonic::IntoRequest<super::PlayArtistTracksRequest>, 2379 2379 - ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status> 2380 2380 - { 2381 2381 - self.inner.ready().await.map_err(|e| { 2382 2382 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2383 2383 - })?; 2733 2733 + ) -> std::result::Result< 2734 2734 + tonic::Response<super::PlayArtistTracksResponse>, 2735 2735 + tonic::Status, 2736 2736 + > { 2737 2737 + self.inner 2738 2738 + .ready() 2739 2739 + .await 2740 2740 + .map_err(|e| { 2741 2741 + tonic::Status::unknown( 2742 2742 + format!("Service was not ready: {}", e.into()), 2743 2743 + ) 2744 2744 + })?; 2384 2745 let codec = tonic::codec::ProstCodec::default(); 2385 2746 let path = http::uri::PathAndQuery::from_static( 2386 2747 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks", 2387 2748 ); 2388 2749 let mut req = request.into_request(); 2389 2389 - req.extensions_mut().insert(GrpcMethod::new( 2390 2390 - "rockbox.v1alpha1.PlaybackService", 2391 2391 - "PlayArtistTracks", 2392 2392 - )); 2750 2750 + req.extensions_mut() 2751 2751 + .insert( 2752 2752 + GrpcMethod::new( 2753 2753 + "rockbox.v1alpha1.PlaybackService", 2754 2754 + "PlayArtistTracks", 2755 2755 + ), 2756 2756 + ); 2393 2757 self.inner.unary(req, path, codec).await 2394 2758 } 2395 2759 pub async fn play_playlist( 2396 2760 &mut self, 2397 2761 request: impl tonic::IntoRequest<super::PlayPlaylistRequest>, 2398 2398 - ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status> 2399 2399 - { 2400 2400 - self.inner.ready().await.map_err(|e| { 2401 2401 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2402 2402 - })?; 2762 2762 + ) -> std::result::Result< 2763 2763 + tonic::Response<super::PlayPlaylistResponse>, 2764 2764 + tonic::Status, 2765 2765 + > { 2766 2766 + self.inner 2767 2767 + .ready() 2768 2768 + .await 2769 2769 + .map_err(|e| { 2770 2770 + tonic::Status::unknown( 2771 2771 + format!("Service was not ready: {}", e.into()), 2772 2772 + ) 2773 2773 + })?; 2403 2774 let codec = tonic::codec::ProstCodec::default(); 2404 2775 let path = http::uri::PathAndQuery::from_static( 2405 2776 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist", 2406 2777 ); 2407 2778 let mut req = request.into_request(); 2408 2408 - req.extensions_mut().insert(GrpcMethod::new( 2409 2409 - "rockbox.v1alpha1.PlaybackService", 2410 2410 - "PlayPlaylist", 2411 2411 - )); 2779 2779 + req.extensions_mut() 2780 2780 + .insert( 2781 2781 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayPlaylist"), 2782 2782 + ); 2412 2783 self.inner.unary(req, path, codec).await 2413 2784 } 2414 2785 pub async fn play_directory( 2415 2786 &mut self, 2416 2787 request: impl tonic::IntoRequest<super::PlayDirectoryRequest>, 2417 2417 - ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status> 2418 2418 - { 2419 2419 - self.inner.ready().await.map_err(|e| { 2420 2420 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2421 2421 - })?; 2788 2788 + ) -> std::result::Result< 2789 2789 + tonic::Response<super::PlayDirectoryResponse>, 2790 2790 + tonic::Status, 2791 2791 + > { 2792 2792 + self.inner 2793 2793 + .ready() 2794 2794 + .await 2795 2795 + .map_err(|e| { 2796 2796 + tonic::Status::unknown( 2797 2797 + format!("Service was not ready: {}", e.into()), 2798 2798 + ) 2799 2799 + })?; 2422 2800 let codec = tonic::codec::ProstCodec::default(); 2423 2801 let path = http::uri::PathAndQuery::from_static( 2424 2802 "/rockbox.v1alpha1.PlaybackService/PlayDirectory", 2425 2803 ); 2426 2804 let mut req = request.into_request(); 2427 2427 - req.extensions_mut().insert(GrpcMethod::new( 2428 2428 - "rockbox.v1alpha1.PlaybackService", 2429 2429 - "PlayDirectory", 2430 2430 - )); 2805 2805 + req.extensions_mut() 2806 2806 + .insert( 2807 2807 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayDirectory"), 2808 2808 + ); 2431 2809 self.inner.unary(req, path, codec).await 2432 2810 } 2433 2811 pub async fn play_track( 2434 2812 &mut self, 2435 2813 request: impl tonic::IntoRequest<super::PlayTrackRequest>, 2436 2436 - ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status> { 2437 2437 - self.inner.ready().await.map_err(|e| { 2438 2438 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2439 2439 - })?; 2814 2814 + ) -> std::result::Result< 2815 2815 + tonic::Response<super::PlayTrackResponse>, 2816 2816 + tonic::Status, 2817 2817 + > { 2818 2818 + self.inner 2819 2819 + .ready() 2820 2820 + .await 2821 2821 + .map_err(|e| { 2822 2822 + tonic::Status::unknown( 2823 2823 + format!("Service was not ready: {}", e.into()), 2824 2824 + ) 2825 2825 + })?; 2440 2826 let codec = tonic::codec::ProstCodec::default(); 2441 2441 - let path = 2442 2442 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayTrack"); 2827 2827 + let path = http::uri::PathAndQuery::from_static( 2828 2828 + "/rockbox.v1alpha1.PlaybackService/PlayTrack", 2829 2829 + ); 2443 2830 let mut req = request.into_request(); 2444 2444 - req.extensions_mut().insert(GrpcMethod::new( 2445 2445 - "rockbox.v1alpha1.PlaybackService", 2446 2446 - "PlayTrack", 2447 2447 - )); 2831 2831 + req.extensions_mut() 2832 2832 + .insert( 2833 2833 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayTrack"), 2834 2834 + ); 2448 2835 self.inner.unary(req, path, codec).await 2449 2836 } 2450 2837 pub async fn play_liked_tracks( 2451 2838 &mut self, 2452 2839 request: impl tonic::IntoRequest<super::PlayLikedTracksRequest>, 2453 2453 - ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status> 2454 2454 - { 2455 2455 - self.inner.ready().await.map_err(|e| { 2456 2456 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2457 2457 - })?; 2840 2840 + ) -> std::result::Result< 2841 2841 + tonic::Response<super::PlayLikedTracksResponse>, 2842 2842 + tonic::Status, 2843 2843 + > { 2844 2844 + self.inner 2845 2845 + .ready() 2846 2846 + .await 2847 2847 + .map_err(|e| { 2848 2848 + tonic::Status::unknown( 2849 2849 + format!("Service was not ready: {}", e.into()), 2850 2850 + ) 2851 2851 + })?; 2458 2852 let codec = tonic::codec::ProstCodec::default(); 2459 2853 let path = http::uri::PathAndQuery::from_static( 2460 2854 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks", 2461 2855 ); 2462 2856 let mut req = request.into_request(); 2463 2463 - req.extensions_mut().insert(GrpcMethod::new( 2464 2464 - "rockbox.v1alpha1.PlaybackService", 2465 2465 - "PlayLikedTracks", 2466 2466 - )); 2857 2857 + req.extensions_mut() 2858 2858 + .insert( 2859 2859 + GrpcMethod::new( 2860 2860 + "rockbox.v1alpha1.PlaybackService", 2861 2861 + "PlayLikedTracks", 2862 2862 + ), 2863 2863 + ); 2467 2864 self.inner.unary(req, path, codec).await 2468 2865 } 2469 2866 pub async fn play_all_tracks( 2470 2867 &mut self, 2471 2868 request: impl tonic::IntoRequest<super::PlayAllTracksRequest>, 2472 2472 - ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status> 2473 2473 - { 2474 2474 - self.inner.ready().await.map_err(|e| { 2475 2475 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2476 2476 - })?; 2869 2869 + ) -> std::result::Result< 2870 2870 + tonic::Response<super::PlayAllTracksResponse>, 2871 2871 + tonic::Status, 2872 2872 + > { 2873 2873 + self.inner 2874 2874 + .ready() 2875 2875 + .await 2876 2876 + .map_err(|e| { 2877 2877 + tonic::Status::unknown( 2878 2878 + format!("Service was not ready: {}", e.into()), 2879 2879 + ) 2880 2880 + })?; 2477 2881 let codec = tonic::codec::ProstCodec::default(); 2478 2882 let path = http::uri::PathAndQuery::from_static( 2479 2883 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks", 2480 2884 ); 2481 2885 let mut req = request.into_request(); 2482 2482 - req.extensions_mut().insert(GrpcMethod::new( 2483 2483 - "rockbox.v1alpha1.PlaybackService", 2484 2484 - "PlayAllTracks", 2485 2485 - )); 2886 2886 + req.extensions_mut() 2887 2887 + .insert( 2888 2888 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAllTracks"), 2889 2889 + ); 2486 2890 self.inner.unary(req, path, codec).await 2487 2891 } 2488 2892 pub async fn stream_current_track( ··· 2492 2896 tonic::Response<tonic::codec::Streaming<super::CurrentTrackResponse>>, 2493 2897 tonic::Status, 2494 2898 > { 2495 2495 - self.inner.ready().await.map_err(|e| { 2496 2496 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2497 2497 - })?; 2899 2899 + self.inner 2900 2900 + .ready() 2901 2901 + .await 2902 2902 + .map_err(|e| { 2903 2903 + tonic::Status::unknown( 2904 2904 + format!("Service was not ready: {}", e.into()), 2905 2905 + ) 2906 2906 + })?; 2498 2907 let codec = tonic::codec::ProstCodec::default(); 2499 2908 let path = http::uri::PathAndQuery::from_static( 2500 2909 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack", 2501 2910 ); 2502 2911 let mut req = request.into_request(); 2503 2503 - req.extensions_mut().insert(GrpcMethod::new( 2504 2504 - "rockbox.v1alpha1.PlaybackService", 2505 2505 - "StreamCurrentTrack", 2506 2506 - )); 2912 2912 + req.extensions_mut() 2913 2913 + .insert( 2914 2914 + GrpcMethod::new( 2915 2915 + "rockbox.v1alpha1.PlaybackService", 2916 2916 + "StreamCurrentTrack", 2917 2917 + ), 2918 2918 + ); 2507 2919 self.inner.server_streaming(req, path, codec).await 2508 2920 } 2509 2921 pub async fn stream_status( ··· 2513 2925 tonic::Response<tonic::codec::Streaming<super::StatusResponse>>, 2514 2926 tonic::Status, 2515 2927 > { 2516 2516 - self.inner.ready().await.map_err(|e| { 2517 2517 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2518 2518 - })?; 2928 2928 + self.inner 2929 2929 + .ready() 2930 2930 + .await 2931 2931 + .map_err(|e| { 2932 2932 + tonic::Status::unknown( 2933 2933 + format!("Service was not ready: {}", e.into()), 2934 2934 + ) 2935 2935 + })?; 2519 2936 let codec = tonic::codec::ProstCodec::default(); 2520 2937 let path = http::uri::PathAndQuery::from_static( 2521 2938 "/rockbox.v1alpha1.PlaybackService/StreamStatus", 2522 2939 ); 2523 2940 let mut req = request.into_request(); 2524 2524 - req.extensions_mut().insert(GrpcMethod::new( 2525 2525 - "rockbox.v1alpha1.PlaybackService", 2526 2526 - "StreamStatus", 2527 2527 - )); 2941 2941 + req.extensions_mut() 2942 2942 + .insert( 2943 2943 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamStatus"), 2944 2944 + ); 2528 2945 self.inner.server_streaming(req, path, codec).await 2529 2946 } 2530 2947 pub async fn stream_playlist( ··· 2534 2951 tonic::Response<tonic::codec::Streaming<super::PlaylistResponse>>, 2535 2952 tonic::Status, 2536 2953 > { 2537 2537 - self.inner.ready().await.map_err(|e| { 2538 2538 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2539 2539 - })?; 2954 2954 + self.inner 2955 2955 + .ready() 2956 2956 + .await 2957 2957 + .map_err(|e| { 2958 2958 + tonic::Status::unknown( 2959 2959 + format!("Service was not ready: {}", e.into()), 2960 2960 + ) 2961 2961 + })?; 2540 2962 let codec = tonic::codec::ProstCodec::default(); 2541 2963 let path = http::uri::PathAndQuery::from_static( 2542 2964 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist", 2543 2965 ); 2544 2966 let mut req = request.into_request(); 2545 2545 - req.extensions_mut().insert(GrpcMethod::new( 2546 2546 - "rockbox.v1alpha1.PlaybackService", 2547 2547 - "StreamPlaylist", 2548 2548 - )); 2967 2967 + req.extensions_mut() 2968 2968 + .insert( 2969 2969 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamPlaylist"), 2970 2970 + ); 2549 2971 self.inner.server_streaming(req, path, codec).await 2550 2972 } 2551 2973 } ··· 2557 2979 dead_code, 2558 2980 missing_docs, 2559 2981 clippy::wildcard_imports, 2560 2560 - clippy::let_unit_value 2982 2982 + clippy::let_unit_value, 2561 2983 )] 2562 2984 use tonic::codegen::*; 2563 2985 /// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer. ··· 2574 2996 async fn play_or_pause( 2575 2997 &self, 2576 2998 request: tonic::Request<super::PlayOrPauseRequest>, 2577 2577 - ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status>; 2999 2999 + ) -> std::result::Result< 3000 3000 + tonic::Response<super::PlayOrPauseResponse>, 3001 3001 + tonic::Status, 3002 3002 + >; 2578 3003 async fn resume( 2579 3004 &self, 2580 3005 request: tonic::Request<super::ResumeRequest>, ··· 2586 3011 async fn previous( 2587 3012 &self, 2588 3013 request: tonic::Request<super::PreviousRequest>, 2589 2589 - ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status>; 3014 3014 + ) -> std::result::Result< 3015 3015 + tonic::Response<super::PreviousResponse>, 3016 3016 + tonic::Status, 3017 3017 + >; 2590 3018 async fn fast_forward_rewind( 2591 3019 &self, 2592 3020 request: tonic::Request<super::FastForwardRewindRequest>, 2593 2593 - ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>; 3021 3021 + ) -> std::result::Result< 3022 3022 + tonic::Response<super::FastForwardRewindResponse>, 3023 3023 + tonic::Status, 3024 3024 + >; 2594 3025 async fn status( 2595 3026 &self, 2596 3027 request: tonic::Request<super::StatusRequest>, ··· 2598 3029 async fn current_track( 2599 3030 &self, 2600 3031 request: tonic::Request<super::CurrentTrackRequest>, 2601 2601 - ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status>; 3032 3032 + ) -> std::result::Result< 3033 3033 + tonic::Response<super::CurrentTrackResponse>, 3034 3034 + tonic::Status, 3035 3035 + >; 2602 3036 async fn next_track( 2603 3037 &self, 2604 3038 request: tonic::Request<super::NextTrackRequest>, 2605 2605 - ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status>; 3039 3039 + ) -> std::result::Result< 3040 3040 + tonic::Response<super::NextTrackResponse>, 3041 3041 + tonic::Status, 3042 3042 + >; 2606 3043 async fn flush_and_reload_tracks( 2607 3044 &self, 2608 3045 request: tonic::Request<super::FlushAndReloadTracksRequest>, 2609 2609 - ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status>; 3046 3046 + ) -> std::result::Result< 3047 3047 + tonic::Response<super::FlushAndReloadTracksResponse>, 3048 3048 + tonic::Status, 3049 3049 + >; 2610 3050 async fn get_file_position( 2611 3051 &self, 2612 3052 request: tonic::Request<super::GetFilePositionRequest>, 2613 2613 - ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status>; 3053 3053 + ) -> std::result::Result< 3054 3054 + tonic::Response<super::GetFilePositionResponse>, 3055 3055 + tonic::Status, 3056 3056 + >; 2614 3057 async fn hard_stop( 2615 3058 &self, 2616 3059 request: tonic::Request<super::HardStopRequest>, 2617 2617 - ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status>; 3060 3060 + ) -> std::result::Result< 3061 3061 + tonic::Response<super::HardStopResponse>, 3062 3062 + tonic::Status, 3063 3063 + >; 2618 3064 async fn play_album( 2619 3065 &self, 2620 3066 request: tonic::Request<super::PlayAlbumRequest>, 2621 2621 - ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status>; 3067 3067 + ) -> std::result::Result< 3068 3068 + tonic::Response<super::PlayAlbumResponse>, 3069 3069 + tonic::Status, 3070 3070 + >; 2622 3071 async fn play_artist_tracks( 2623 3072 &self, 2624 3073 request: tonic::Request<super::PlayArtistTracksRequest>, 2625 2625 - ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status>; 3074 3074 + ) -> std::result::Result< 3075 3075 + tonic::Response<super::PlayArtistTracksResponse>, 3076 3076 + tonic::Status, 3077 3077 + >; 2626 3078 async fn play_playlist( 2627 3079 &self, 2628 3080 request: tonic::Request<super::PlayPlaylistRequest>, 2629 2629 - ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status>; 3081 3081 + ) -> std::result::Result< 3082 3082 + tonic::Response<super::PlayPlaylistResponse>, 3083 3083 + tonic::Status, 3084 3084 + >; 2630 3085 async fn play_directory( 2631 3086 &self, 2632 3087 request: tonic::Request<super::PlayDirectoryRequest>, 2633 2633 - ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>; 3088 3088 + ) -> std::result::Result< 3089 3089 + tonic::Response<super::PlayDirectoryResponse>, 3090 3090 + tonic::Status, 3091 3091 + >; 2634 3092 async fn play_track( 2635 3093 &self, 2636 3094 request: tonic::Request<super::PlayTrackRequest>, 2637 2637 - ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status>; 3095 3095 + ) -> std::result::Result< 3096 3096 + tonic::Response<super::PlayTrackResponse>, 3097 3097 + tonic::Status, 3098 3098 + >; 2638 3099 async fn play_liked_tracks( 2639 3100 &self, 2640 3101 request: tonic::Request<super::PlayLikedTracksRequest>, 2641 2641 - ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status>; 3102 3102 + ) -> std::result::Result< 3103 3103 + tonic::Response<super::PlayLikedTracksResponse>, 3104 3104 + tonic::Status, 3105 3105 + >; 2642 3106 async fn play_all_tracks( 2643 3107 &self, 2644 3108 request: tonic::Request<super::PlayAllTracksRequest>, 2645 2645 - ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>; 3109 3109 + ) -> std::result::Result< 3110 3110 + tonic::Response<super::PlayAllTracksResponse>, 3111 3111 + tonic::Status, 3112 3112 + >; 2646 3113 /// Server streaming response type for the StreamCurrentTrack method. 2647 3114 type StreamCurrentTrackStream: tonic::codegen::tokio_stream::Stream< 2648 3115 Item = std::result::Result<super::CurrentTrackResponse, tonic::Status>, 2649 2649 - > + std::marker::Send 3116 3116 + > 3117 3117 + + std::marker::Send 2650 3118 + 'static; 2651 3119 async fn stream_current_track( 2652 3120 &self, 2653 3121 request: tonic::Request<super::StreamCurrentTrackRequest>, 2654 2654 - ) -> std::result::Result<tonic::Response<Self::StreamCurrentTrackStream>, tonic::Status>; 3122 3122 + ) -> std::result::Result< 3123 3123 + tonic::Response<Self::StreamCurrentTrackStream>, 3124 3124 + tonic::Status, 3125 3125 + >; 2655 3126 /// Server streaming response type for the StreamStatus method. 2656 3127 type StreamStatusStream: tonic::codegen::tokio_stream::Stream< 2657 3128 Item = std::result::Result<super::StatusResponse, tonic::Status>, 2658 2658 - > + std::marker::Send 3129 3129 + > 3130 3130 + + std::marker::Send 2659 3131 + 'static; 2660 3132 async fn stream_status( 2661 3133 &self, 2662 3134 request: tonic::Request<super::StreamStatusRequest>, 2663 2663 - ) -> std::result::Result<tonic::Response<Self::StreamStatusStream>, tonic::Status>; 3135 3135 + ) -> std::result::Result< 3136 3136 + tonic::Response<Self::StreamStatusStream>, 3137 3137 + tonic::Status, 3138 3138 + >; 2664 3139 /// Server streaming response type for the StreamPlaylist method. 2665 3140 type StreamPlaylistStream: tonic::codegen::tokio_stream::Stream< 2666 3141 Item = std::result::Result<super::PlaylistResponse, tonic::Status>, 2667 2667 - > + std::marker::Send 3142 3142 + > 3143 3143 + + std::marker::Send 2668 3144 + 'static; 2669 3145 async fn stream_playlist( 2670 3146 &self, 2671 3147 request: tonic::Request<super::StreamPlaylistRequest>, 2672 2672 - ) -> std::result::Result<tonic::Response<Self::StreamPlaylistStream>, tonic::Status>; 3148 3148 + ) -> std::result::Result< 3149 3149 + tonic::Response<Self::StreamPlaylistStream>, 3150 3150 + tonic::Status, 3151 3151 + >; 2673 3152 } 2674 3153 #[derive(Debug)] 2675 3154 pub struct PlaybackServiceServer<T> { ··· 2692 3171 max_encoding_message_size: None, 2693 3172 } 2694 3173 } 2695 2695 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 3174 3174 + pub fn with_interceptor<F>( 3175 3175 + inner: T, 3176 3176 + interceptor: F, 3177 3177 + ) -> InterceptedService<Self, F> 2696 3178 where 2697 3179 F: tonic::service::Interceptor, 2698 3180 { ··· 2747 3229 "/rockbox.v1alpha1.PlaybackService/Play" => { 2748 3230 #[allow(non_camel_case_types)] 2749 3231 struct PlaySvc<T: PlaybackService>(pub Arc<T>); 2750 2750 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 3232 3232 + impl< 3233 3233 + T: PlaybackService, 3234 3234 + > tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 2751 3235 type Response = super::PlayResponse; 2752 2752 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3236 3236 + type Future = BoxFuture< 3237 3237 + tonic::Response<Self::Response>, 3238 3238 + tonic::Status, 3239 3239 + >; 2753 3240 fn call( 2754 3241 &mut self, 2755 3242 request: tonic::Request<super::PlayRequest>, 2756 3243 ) -> Self::Future { 2757 3244 let inner = Arc::clone(&self.0); 2758 2758 - let fut = 2759 2759 - async move { <T as PlaybackService>::play(&inner, request).await }; 3245 3245 + let fut = async move { 3246 3246 + <T as PlaybackService>::play(&inner, request).await 3247 3247 + }; 2760 3248 Box::pin(fut) 2761 3249 } 2762 3250 } ··· 2785 3273 "/rockbox.v1alpha1.PlaybackService/Pause" => { 2786 3274 #[allow(non_camel_case_types)] 2787 3275 struct PauseSvc<T: PlaybackService>(pub Arc<T>); 2788 2788 - impl<T: PlaybackService> tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 3276 3276 + impl< 3277 3277 + T: PlaybackService, 3278 3278 + > tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 2789 3279 type Response = super::PauseResponse; 2790 2790 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3280 3280 + type Future = BoxFuture< 3281 3281 + tonic::Response<Self::Response>, 3282 3282 + tonic::Status, 3283 3283 + >; 2791 3284 fn call( 2792 3285 &mut self, 2793 3286 request: tonic::Request<super::PauseRequest>, 2794 3287 ) -> Self::Future { 2795 3288 let inner = Arc::clone(&self.0); 2796 2796 - let fut = 2797 2797 - async move { <T as PlaybackService>::pause(&inner, request).await }; 3289 3289 + let fut = async move { 3290 3290 + <T as PlaybackService>::pause(&inner, request).await 3291 3291 + }; 2798 3292 Box::pin(fut) 2799 3293 } 2800 3294 } ··· 2823 3317 "/rockbox.v1alpha1.PlaybackService/PlayOrPause" => { 2824 3318 #[allow(non_camel_case_types)] 2825 3319 struct PlayOrPauseSvc<T: PlaybackService>(pub Arc<T>); 2826 2826 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayOrPauseRequest> 2827 2827 - for PlayOrPauseSvc<T> 2828 2828 - { 3320 3320 + impl< 3321 3321 + T: PlaybackService, 3322 3322 + > tonic::server::UnaryService<super::PlayOrPauseRequest> 3323 3323 + for PlayOrPauseSvc<T> { 2829 3324 type Response = super::PlayOrPauseResponse; 2830 2830 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3325 3325 + type Future = BoxFuture< 3326 3326 + tonic::Response<Self::Response>, 3327 3327 + tonic::Status, 3328 3328 + >; 2831 3329 fn call( 2832 3330 &mut self, 2833 3331 request: tonic::Request<super::PlayOrPauseRequest>, ··· 2864 3362 "/rockbox.v1alpha1.PlaybackService/Resume" => { 2865 3363 #[allow(non_camel_case_types)] 2866 3364 struct ResumeSvc<T: PlaybackService>(pub Arc<T>); 2867 2867 - impl<T: PlaybackService> tonic::server::UnaryService<super::ResumeRequest> for ResumeSvc<T> { 3365 3365 + impl< 3366 3366 + T: PlaybackService, 3367 3367 + > tonic::server::UnaryService<super::ResumeRequest> 3368 3368 + for ResumeSvc<T> { 2868 3369 type Response = super::ResumeResponse; 2869 2869 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3370 3370 + type Future = BoxFuture< 3371 3371 + tonic::Response<Self::Response>, 3372 3372 + tonic::Status, 3373 3373 + >; 2870 3374 fn call( 2871 3375 &mut self, 2872 3376 request: tonic::Request<super::ResumeRequest>, ··· 2903 3407 "/rockbox.v1alpha1.PlaybackService/Next" => { 2904 3408 #[allow(non_camel_case_types)] 2905 3409 struct NextSvc<T: PlaybackService>(pub Arc<T>); 2906 2906 - impl<T: PlaybackService> tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 3410 3410 + impl< 3411 3411 + T: PlaybackService, 3412 3412 + > tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 2907 3413 type Response = super::NextResponse; 2908 2908 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3414 3414 + type Future = BoxFuture< 3415 3415 + tonic::Response<Self::Response>, 3416 3416 + tonic::Status, 3417 3417 + >; 2909 3418 fn call( 2910 3419 &mut self, 2911 3420 request: tonic::Request<super::NextRequest>, 2912 3421 ) -> Self::Future { 2913 3422 let inner = Arc::clone(&self.0); 2914 2914 - let fut = 2915 2915 - async move { <T as PlaybackService>::next(&inner, request).await }; 3423 3423 + let fut = async move { 3424 3424 + <T as PlaybackService>::next(&inner, request).await 3425 3425 + }; 2916 3426 Box::pin(fut) 2917 3427 } 2918 3428 } ··· 2941 3451 "/rockbox.v1alpha1.PlaybackService/Previous" => { 2942 3452 #[allow(non_camel_case_types)] 2943 3453 struct PreviousSvc<T: PlaybackService>(pub Arc<T>); 2944 2944 - impl<T: PlaybackService> tonic::server::UnaryService<super::PreviousRequest> for PreviousSvc<T> { 3454 3454 + impl< 3455 3455 + T: PlaybackService, 3456 3456 + > tonic::server::UnaryService<super::PreviousRequest> 3457 3457 + for PreviousSvc<T> { 2945 3458 type Response = super::PreviousResponse; 2946 2946 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3459 3459 + type Future = BoxFuture< 3460 3460 + tonic::Response<Self::Response>, 3461 3461 + tonic::Status, 3462 3462 + >; 2947 3463 fn call( 2948 3464 &mut self, 2949 3465 request: tonic::Request<super::PreviousRequest>, ··· 2980 3496 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind" => { 2981 3497 #[allow(non_camel_case_types)] 2982 3498 struct FastForwardRewindSvc<T: PlaybackService>(pub Arc<T>); 2983 2983 - impl<T: PlaybackService> 2984 2984 - tonic::server::UnaryService<super::FastForwardRewindRequest> 2985 2985 - for FastForwardRewindSvc<T> 2986 2986 - { 3499 3499 + impl< 3500 3500 + T: PlaybackService, 3501 3501 + > tonic::server::UnaryService<super::FastForwardRewindRequest> 3502 3502 + for FastForwardRewindSvc<T> { 2987 3503 type Response = super::FastForwardRewindResponse; 2988 2988 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3504 3504 + type Future = BoxFuture< 3505 3505 + tonic::Response<Self::Response>, 3506 3506 + tonic::Status, 3507 3507 + >; 2989 3508 fn call( 2990 3509 &mut self, 2991 3510 request: tonic::Request<super::FastForwardRewindRequest>, 2992 3511 ) -> Self::Future { 2993 3512 let inner = Arc::clone(&self.0); 2994 3513 let fut = async move { 2995 2995 - <T as PlaybackService>::fast_forward_rewind(&inner, request).await 3514 3514 + <T as PlaybackService>::fast_forward_rewind(&inner, request) 3515 3515 + .await 2996 3516 }; 2997 3517 Box::pin(fut) 2998 3518 } ··· 3022 3542 "/rockbox.v1alpha1.PlaybackService/Status" => { 3023 3543 #[allow(non_camel_case_types)] 3024 3544 struct StatusSvc<T: PlaybackService>(pub Arc<T>); 3025 3025 - impl<T: PlaybackService> tonic::server::UnaryService<super::StatusRequest> for StatusSvc<T> { 3545 3545 + impl< 3546 3546 + T: PlaybackService, 3547 3547 + > tonic::server::UnaryService<super::StatusRequest> 3548 3548 + for StatusSvc<T> { 3026 3549 type Response = super::StatusResponse; 3027 3027 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3550 3550 + type Future = BoxFuture< 3551 3551 + tonic::Response<Self::Response>, 3552 3552 + tonic::Status, 3553 3553 + >; 3028 3554 fn call( 3029 3555 &mut self, 3030 3556 request: tonic::Request<super::StatusRequest>, ··· 3061 3587 "/rockbox.v1alpha1.PlaybackService/CurrentTrack" => { 3062 3588 #[allow(non_camel_case_types)] 3063 3589 struct CurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 3064 3064 - impl<T: PlaybackService> tonic::server::UnaryService<super::CurrentTrackRequest> 3065 3065 - for CurrentTrackSvc<T> 3066 3066 - { 3590 3590 + impl< 3591 3591 + T: PlaybackService, 3592 3592 + > tonic::server::UnaryService<super::CurrentTrackRequest> 3593 3593 + for CurrentTrackSvc<T> { 3067 3594 type Response = super::CurrentTrackResponse; 3068 3068 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3595 3595 + type Future = BoxFuture< 3596 3596 + tonic::Response<Self::Response>, 3597 3597 + tonic::Status, 3598 3598 + >; 3069 3599 fn call( 3070 3600 &mut self, 3071 3601 request: tonic::Request<super::CurrentTrackRequest>, ··· 3102 3632 "/rockbox.v1alpha1.PlaybackService/NextTrack" => { 3103 3633 #[allow(non_camel_case_types)] 3104 3634 struct NextTrackSvc<T: PlaybackService>(pub Arc<T>); 3105 3105 - impl<T: PlaybackService> tonic::server::UnaryService<super::NextTrackRequest> for NextTrackSvc<T> { 3635 3635 + impl< 3636 3636 + T: PlaybackService, 3637 3637 + > tonic::server::UnaryService<super::NextTrackRequest> 3638 3638 + for NextTrackSvc<T> { 3106 3639 type Response = super::NextTrackResponse; 3107 3107 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3640 3640 + type Future = BoxFuture< 3641 3641 + tonic::Response<Self::Response>, 3642 3642 + tonic::Status, 3643 3643 + >; 3108 3644 fn call( 3109 3645 &mut self, 3110 3646 request: tonic::Request<super::NextTrackRequest>, ··· 3141 3677 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks" => { 3142 3678 #[allow(non_camel_case_types)] 3143 3679 struct FlushAndReloadTracksSvc<T: PlaybackService>(pub Arc<T>); 3144 3144 - impl<T: PlaybackService> 3145 3145 - tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3146 3146 - for FlushAndReloadTracksSvc<T> 3147 3147 - { 3680 3680 + impl< 3681 3681 + T: PlaybackService, 3682 3682 + > tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3683 3683 + for FlushAndReloadTracksSvc<T> { 3148 3684 type Response = super::FlushAndReloadTracksResponse; 3149 3149 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3685 3685 + type Future = BoxFuture< 3686 3686 + tonic::Response<Self::Response>, 3687 3687 + tonic::Status, 3688 3688 + >; 3150 3689 fn call( 3151 3690 &mut self, 3152 3691 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3153 3692 ) -> Self::Future { 3154 3693 let inner = Arc::clone(&self.0); 3155 3694 let fut = async move { 3156 3156 - <T as PlaybackService>::flush_and_reload_tracks(&inner, request) 3695 3695 + <T as PlaybackService>::flush_and_reload_tracks( 3696 3696 + &inner, 3697 3697 + request, 3698 3698 + ) 3157 3699 .await 3158 3700 }; 3159 3701 Box::pin(fut) ··· 3184 3726 "/rockbox.v1alpha1.PlaybackService/GetFilePosition" => { 3185 3727 #[allow(non_camel_case_types)] 3186 3728 struct GetFilePositionSvc<T: PlaybackService>(pub Arc<T>); 3187 3187 - impl<T: PlaybackService> 3188 3188 - tonic::server::UnaryService<super::GetFilePositionRequest> 3189 3189 - for GetFilePositionSvc<T> 3190 3190 - { 3729 3729 + impl< 3730 3730 + T: PlaybackService, 3731 3731 + > tonic::server::UnaryService<super::GetFilePositionRequest> 3732 3732 + for GetFilePositionSvc<T> { 3191 3733 type Response = super::GetFilePositionResponse; 3192 3192 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3734 3734 + type Future = BoxFuture< 3735 3735 + tonic::Response<Self::Response>, 3736 3736 + tonic::Status, 3737 3737 + >; 3193 3738 fn call( 3194 3739 &mut self, 3195 3740 request: tonic::Request<super::GetFilePositionRequest>, 3196 3741 ) -> Self::Future { 3197 3742 let inner = Arc::clone(&self.0); 3198 3743 let fut = async move { 3199 3199 - <T as PlaybackService>::get_file_position(&inner, request).await 3744 3744 + <T as PlaybackService>::get_file_position(&inner, request) 3745 3745 + .await 3200 3746 }; 3201 3747 Box::pin(fut) 3202 3748 } ··· 3226 3772 "/rockbox.v1alpha1.PlaybackService/HardStop" => { 3227 3773 #[allow(non_camel_case_types)] 3228 3774 struct HardStopSvc<T: PlaybackService>(pub Arc<T>); 3229 3229 - impl<T: PlaybackService> tonic::server::UnaryService<super::HardStopRequest> for HardStopSvc<T> { 3775 3775 + impl< 3776 3776 + T: PlaybackService, 3777 3777 + > tonic::server::UnaryService<super::HardStopRequest> 3778 3778 + for HardStopSvc<T> { 3230 3779 type Response = super::HardStopResponse; 3231 3231 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3780 3780 + type Future = BoxFuture< 3781 3781 + tonic::Response<Self::Response>, 3782 3782 + tonic::Status, 3783 3783 + >; 3232 3784 fn call( 3233 3785 &mut self, 3234 3786 request: tonic::Request<super::HardStopRequest>, ··· 3265 3817 "/rockbox.v1alpha1.PlaybackService/PlayAlbum" => { 3266 3818 #[allow(non_camel_case_types)] 3267 3819 struct PlayAlbumSvc<T: PlaybackService>(pub Arc<T>); 3268 3268 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayAlbumRequest> for PlayAlbumSvc<T> { 3820 3820 + impl< 3821 3821 + T: PlaybackService, 3822 3822 + > tonic::server::UnaryService<super::PlayAlbumRequest> 3823 3823 + for PlayAlbumSvc<T> { 3269 3824 type Response = super::PlayAlbumResponse; 3270 3270 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3825 3825 + type Future = BoxFuture< 3826 3826 + tonic::Response<Self::Response>, 3827 3827 + tonic::Status, 3828 3828 + >; 3271 3829 fn call( 3272 3830 &mut self, 3273 3831 request: tonic::Request<super::PlayAlbumRequest>, ··· 3304 3862 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks" => { 3305 3863 #[allow(non_camel_case_types)] 3306 3864 struct PlayArtistTracksSvc<T: PlaybackService>(pub Arc<T>); 3307 3307 - impl<T: PlaybackService> 3308 3308 - tonic::server::UnaryService<super::PlayArtistTracksRequest> 3309 3309 - for PlayArtistTracksSvc<T> 3310 3310 - { 3865 3865 + impl< 3866 3866 + T: PlaybackService, 3867 3867 + > tonic::server::UnaryService<super::PlayArtistTracksRequest> 3868 3868 + for PlayArtistTracksSvc<T> { 3311 3869 type Response = super::PlayArtistTracksResponse; 3312 3312 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3870 3870 + type Future = BoxFuture< 3871 3871 + tonic::Response<Self::Response>, 3872 3872 + tonic::Status, 3873 3873 + >; 3313 3874 fn call( 3314 3875 &mut self, 3315 3876 request: tonic::Request<super::PlayArtistTracksRequest>, 3316 3877 ) -> Self::Future { 3317 3878 let inner = Arc::clone(&self.0); 3318 3879 let fut = async move { 3319 3319 - <T as PlaybackService>::play_artist_tracks(&inner, request).await 3880 3880 + <T as PlaybackService>::play_artist_tracks(&inner, request) 3881 3881 + .await 3320 3882 }; 3321 3883 Box::pin(fut) 3322 3884 } ··· 3346 3908 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist" => { 3347 3909 #[allow(non_camel_case_types)] 3348 3910 struct PlayPlaylistSvc<T: PlaybackService>(pub Arc<T>); 3349 3349 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayPlaylistRequest> 3350 3350 - for PlayPlaylistSvc<T> 3351 3351 - { 3911 3911 + impl< 3912 3912 + T: PlaybackService, 3913 3913 + > tonic::server::UnaryService<super::PlayPlaylistRequest> 3914 3914 + for PlayPlaylistSvc<T> { 3352 3915 type Response = super::PlayPlaylistResponse; 3353 3353 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3916 3916 + type Future = BoxFuture< 3917 3917 + tonic::Response<Self::Response>, 3918 3918 + tonic::Status, 3919 3919 + >; 3354 3920 fn call( 3355 3921 &mut self, 3356 3922 request: tonic::Request<super::PlayPlaylistRequest>, ··· 3387 3953 "/rockbox.v1alpha1.PlaybackService/PlayDirectory" => { 3388 3954 #[allow(non_camel_case_types)] 3389 3955 struct PlayDirectorySvc<T: PlaybackService>(pub Arc<T>); 3390 3390 - impl<T: PlaybackService> 3391 3391 - tonic::server::UnaryService<super::PlayDirectoryRequest> 3392 3392 - for PlayDirectorySvc<T> 3393 3393 - { 3956 3956 + impl< 3957 3957 + T: PlaybackService, 3958 3958 + > tonic::server::UnaryService<super::PlayDirectoryRequest> 3959 3959 + for PlayDirectorySvc<T> { 3394 3960 type Response = super::PlayDirectoryResponse; 3395 3395 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3961 3961 + type Future = BoxFuture< 3962 3962 + tonic::Response<Self::Response>, 3963 3963 + tonic::Status, 3964 3964 + >; 3396 3965 fn call( 3397 3966 &mut self, 3398 3967 request: tonic::Request<super::PlayDirectoryRequest>, 3399 3968 ) -> Self::Future { 3400 3969 let inner = Arc::clone(&self.0); 3401 3970 let fut = async move { 3402 3402 - <T as PlaybackService>::play_directory(&inner, request).await 3971 3971 + <T as PlaybackService>::play_directory(&inner, request) 3972 3972 + .await 3403 3973 }; 3404 3974 Box::pin(fut) 3405 3975 } ··· 3429 3999 "/rockbox.v1alpha1.PlaybackService/PlayTrack" => { 3430 4000 #[allow(non_camel_case_types)] 3431 4001 struct PlayTrackSvc<T: PlaybackService>(pub Arc<T>); 3432 3432 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayTrackRequest> for PlayTrackSvc<T> { 4002 4002 + impl< 4003 4003 + T: PlaybackService, 4004 4004 + > tonic::server::UnaryService<super::PlayTrackRequest> 4005 4005 + for PlayTrackSvc<T> { 3433 4006 type Response = super::PlayTrackResponse; 3434 3434 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4007 4007 + type Future = BoxFuture< 4008 4008 + tonic::Response<Self::Response>, 4009 4009 + tonic::Status, 4010 4010 + >; 3435 4011 fn call( 3436 4012 &mut self, 3437 4013 request: tonic::Request<super::PlayTrackRequest>, ··· 3468 4044 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks" => { 3469 4045 #[allow(non_camel_case_types)] 3470 4046 struct PlayLikedTracksSvc<T: PlaybackService>(pub Arc<T>); 3471 3471 - impl<T: PlaybackService> 3472 3472 - tonic::server::UnaryService<super::PlayLikedTracksRequest> 3473 3473 - for PlayLikedTracksSvc<T> 3474 3474 - { 4047 4047 + impl< 4048 4048 + T: PlaybackService, 4049 4049 + > tonic::server::UnaryService<super::PlayLikedTracksRequest> 4050 4050 + for PlayLikedTracksSvc<T> { 3475 4051 type Response = super::PlayLikedTracksResponse; 3476 3476 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4052 4052 + type Future = BoxFuture< 4053 4053 + tonic::Response<Self::Response>, 4054 4054 + tonic::Status, 4055 4055 + >; 3477 4056 fn call( 3478 4057 &mut self, 3479 4058 request: tonic::Request<super::PlayLikedTracksRequest>, 3480 4059 ) -> Self::Future { 3481 4060 let inner = Arc::clone(&self.0); 3482 4061 let fut = async move { 3483 3483 - <T as PlaybackService>::play_liked_tracks(&inner, request).await 4062 4062 + <T as PlaybackService>::play_liked_tracks(&inner, request) 4063 4063 + .await 3484 4064 }; 3485 4065 Box::pin(fut) 3486 4066 } ··· 3510 4090 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks" => { 3511 4091 #[allow(non_camel_case_types)] 3512 4092 struct PlayAllTracksSvc<T: PlaybackService>(pub Arc<T>); 3513 3513 - impl<T: PlaybackService> 3514 3514 - tonic::server::UnaryService<super::PlayAllTracksRequest> 3515 3515 - for PlayAllTracksSvc<T> 3516 3516 - { 4093 4093 + impl< 4094 4094 + T: PlaybackService, 4095 4095 + > tonic::server::UnaryService<super::PlayAllTracksRequest> 4096 4096 + for PlayAllTracksSvc<T> { 3517 4097 type Response = super::PlayAllTracksResponse; 3518 3518 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4098 4098 + type Future = BoxFuture< 4099 4099 + tonic::Response<Self::Response>, 4100 4100 + tonic::Status, 4101 4101 + >; 3519 4102 fn call( 3520 4103 &mut self, 3521 4104 request: tonic::Request<super::PlayAllTracksRequest>, 3522 4105 ) -> Self::Future { 3523 4106 let inner = Arc::clone(&self.0); 3524 4107 let fut = async move { 3525 3525 - <T as PlaybackService>::play_all_tracks(&inner, request).await 4108 4108 + <T as PlaybackService>::play_all_tracks(&inner, request) 4109 4109 + .await 3526 4110 }; 3527 4111 Box::pin(fut) 3528 4112 } ··· 3552 4136 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack" => { 3553 4137 #[allow(non_camel_case_types)] 3554 4138 struct StreamCurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 3555 3555 - impl<T: PlaybackService> 3556 3556 - tonic::server::ServerStreamingService<super::StreamCurrentTrackRequest> 3557 3557 - for StreamCurrentTrackSvc<T> 3558 3558 - { 4139 4139 + impl< 4140 4140 + T: PlaybackService, 4141 4141 + > tonic::server::ServerStreamingService< 4142 4142 + super::StreamCurrentTrackRequest, 4143 4143 + > for StreamCurrentTrackSvc<T> { 3559 4144 type Response = super::CurrentTrackResponse; 3560 4145 type ResponseStream = T::StreamCurrentTrackStream; 3561 3561 - type Future = 3562 3562 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4146 4146 + type Future = BoxFuture< 4147 4147 + tonic::Response<Self::ResponseStream>, 4148 4148 + tonic::Status, 4149 4149 + >; 3563 4150 fn call( 3564 4151 &mut self, 3565 4152 request: tonic::Request<super::StreamCurrentTrackRequest>, 3566 4153 ) -> Self::Future { 3567 4154 let inner = Arc::clone(&self.0); 3568 4155 let fut = async move { 3569 3569 - <T as PlaybackService>::stream_current_track(&inner, request).await 4156 4156 + <T as PlaybackService>::stream_current_track( 4157 4157 + &inner, 4158 4158 + request, 4159 4159 + ) 4160 4160 + .await 3570 4161 }; 3571 4162 Box::pin(fut) 3572 4163 } ··· 3596 4187 "/rockbox.v1alpha1.PlaybackService/StreamStatus" => { 3597 4188 #[allow(non_camel_case_types)] 3598 4189 struct StreamStatusSvc<T: PlaybackService>(pub Arc<T>); 3599 3599 - impl<T: PlaybackService> 3600 3600 - tonic::server::ServerStreamingService<super::StreamStatusRequest> 3601 3601 - for StreamStatusSvc<T> 3602 3602 - { 4190 4190 + impl< 4191 4191 + T: PlaybackService, 4192 4192 + > tonic::server::ServerStreamingService<super::StreamStatusRequest> 4193 4193 + for StreamStatusSvc<T> { 3603 4194 type Response = super::StatusResponse; 3604 4195 type ResponseStream = T::StreamStatusStream; 3605 3605 - type Future = 3606 3606 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4196 4196 + type Future = BoxFuture< 4197 4197 + tonic::Response<Self::ResponseStream>, 4198 4198 + tonic::Status, 4199 4199 + >; 3607 4200 fn call( 3608 4201 &mut self, 3609 4202 request: tonic::Request<super::StreamStatusRequest>, ··· 3640 4233 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist" => { 3641 4234 #[allow(non_camel_case_types)] 3642 4235 struct StreamPlaylistSvc<T: PlaybackService>(pub Arc<T>); 3643 3643 - impl<T: PlaybackService> 3644 3644 - tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 3645 3645 - for StreamPlaylistSvc<T> 3646 3646 - { 4236 4236 + impl< 4237 4237 + T: PlaybackService, 4238 4238 + > tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 4239 4239 + for StreamPlaylistSvc<T> { 3647 4240 type Response = super::PlaylistResponse; 3648 4241 type ResponseStream = T::StreamPlaylistStream; 3649 3649 - type Future = 3650 3650 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4242 4242 + type Future = BoxFuture< 4243 4243 + tonic::Response<Self::ResponseStream>, 4244 4244 + tonic::Status, 4245 4245 + >; 3651 4246 fn call( 3652 4247 &mut self, 3653 4248 request: tonic::Request<super::StreamPlaylistRequest>, 3654 4249 ) -> Self::Future { 3655 4250 let inner = Arc::clone(&self.0); 3656 4251 let fut = async move { 3657 3657 - <T as PlaybackService>::stream_playlist(&inner, request).await 4252 4252 + <T as PlaybackService>::stream_playlist(&inner, request) 4253 4253 + .await 3658 4254 }; 3659 4255 Box::pin(fut) 3660 4256 } ··· 3681 4277 }; 3682 4278 Box::pin(fut) 3683 4279 } 3684 3684 - _ => Box::pin(async move { 3685 3685 - let mut response = http::Response::new(empty_body()); 3686 3686 - let headers = response.headers_mut(); 3687 3687 - headers.insert( 3688 3688 - tonic::Status::GRPC_STATUS, 3689 3689 - (tonic::Code::Unimplemented as i32).into(), 3690 3690 - ); 3691 3691 - headers.insert( 3692 3692 - http::header::CONTENT_TYPE, 3693 3693 - tonic::metadata::GRPC_CONTENT_TYPE, 3694 3694 - ); 3695 3695 - Ok(response) 3696 3696 - }), 4280 4280 + _ => { 4281 4281 + Box::pin(async move { 4282 4282 + let mut response = http::Response::new(empty_body()); 4283 4283 + let headers = response.headers_mut(); 4284 4284 + headers 4285 4285 + .insert( 4286 4286 + tonic::Status::GRPC_STATUS, 4287 4287 + (tonic::Code::Unimplemented as i32).into(), 4288 4288 + ); 4289 4289 + headers 4290 4290 + .insert( 4291 4291 + http::header::CONTENT_TYPE, 4292 4292 + tonic::metadata::GRPC_CONTENT_TYPE, 4293 4293 + ); 4294 4294 + Ok(response) 4295 4295 + }) 4296 4296 + } 3697 4297 } 3698 4298 } 3699 4299 } ··· 3900 4500 dead_code, 3901 4501 missing_docs, 3902 4502 clippy::wildcard_imports, 3903 3903 - clippy::let_unit_value 4503 4503 + clippy::let_unit_value, 3904 4504 )] 3905 3905 - use tonic::codegen::http::Uri; 3906 4505 use tonic::codegen::*; 4506 4506 + use tonic::codegen::http::Uri; 3907 4507 #[derive(Debug, Clone)] 3908 4508 pub struct PlaylistServiceClient<T> { 3909 4509 inner: tonic::client::Grpc<T>, ··· 3947 4547 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 3948 4548 >, 3949 4549 >, 3950 3950 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 3951 3951 - Into<StdError> + std::marker::Send + std::marker::Sync, 4550 4550 + <T as tonic::codegen::Service< 4551 4551 + http::Request<tonic::body::BoxBody>, 4552 4552 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 3952 4553 { 3953 4554 PlaylistServiceClient::new(InterceptedService::new(inner, interceptor)) 3954 4555 } ··· 3986 4587 pub async fn get_current( 3987 4588 &mut self, 3988 4589 request: impl tonic::IntoRequest<super::GetCurrentRequest>, 3989 3989 - ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status> 3990 3990 - { 3991 3991 - self.inner.ready().await.map_err(|e| { 3992 3992 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3993 3993 - })?; 4590 4590 + ) -> std::result::Result< 4591 4591 + tonic::Response<super::GetCurrentResponse>, 4592 4592 + tonic::Status, 4593 4593 + > { 4594 4594 + self.inner 4595 4595 + .ready() 4596 4596 + .await 4597 4597 + .map_err(|e| { 4598 4598 + tonic::Status::unknown( 4599 4599 + format!("Service was not ready: {}", e.into()), 4600 4600 + ) 4601 4601 + })?; 3994 4602 let codec = tonic::codec::ProstCodec::default(); 3995 4603 let path = http::uri::PathAndQuery::from_static( 3996 4604 "/rockbox.v1alpha1.PlaylistService/GetCurrent", 3997 4605 ); 3998 4606 let mut req = request.into_request(); 3999 3999 - req.extensions_mut().insert(GrpcMethod::new( 4000 4000 - "rockbox.v1alpha1.PlaylistService", 4001 4001 - "GetCurrent", 4002 4002 - )); 4607 4607 + req.extensions_mut() 4608 4608 + .insert( 4609 4609 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetCurrent"), 4610 4610 + ); 4003 4611 self.inner.unary(req, path, codec).await 4004 4612 } 4005 4613 pub async fn get_resume_info( 4006 4614 &mut self, 4007 4615 request: impl tonic::IntoRequest<super::GetResumeInfoRequest>, 4008 4008 - ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status> 4009 4009 - { 4010 4010 - self.inner.ready().await.map_err(|e| { 4011 4011 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4012 4012 - })?; 4616 4616 + ) -> std::result::Result< 4617 4617 + tonic::Response<super::GetResumeInfoResponse>, 4618 4618 + tonic::Status, 4619 4619 + > { 4620 4620 + self.inner 4621 4621 + .ready() 4622 4622 + .await 4623 4623 + .map_err(|e| { 4624 4624 + tonic::Status::unknown( 4625 4625 + format!("Service was not ready: {}", e.into()), 4626 4626 + ) 4627 4627 + })?; 4013 4628 let codec = tonic::codec::ProstCodec::default(); 4014 4629 let path = http::uri::PathAndQuery::from_static( 4015 4630 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo", 4016 4631 ); 4017 4632 let mut req = request.into_request(); 4018 4018 - req.extensions_mut().insert(GrpcMethod::new( 4019 4019 - "rockbox.v1alpha1.PlaylistService", 4020 4020 - "GetResumeInfo", 4021 4021 - )); 4633 4633 + req.extensions_mut() 4634 4634 + .insert( 4635 4635 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetResumeInfo"), 4636 4636 + ); 4022 4637 self.inner.unary(req, path, codec).await 4023 4638 } 4024 4639 pub async fn get_track_info( 4025 4640 &mut self, 4026 4641 request: impl tonic::IntoRequest<super::GetTrackInfoRequest>, 4027 4027 - ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status> 4028 4028 - { 4029 4029 - self.inner.ready().await.map_err(|e| { 4030 4030 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4031 4031 - })?; 4642 4642 + ) -> std::result::Result< 4643 4643 + tonic::Response<super::GetTrackInfoResponse>, 4644 4644 + tonic::Status, 4645 4645 + > { 4646 4646 + self.inner 4647 4647 + .ready() 4648 4648 + .await 4649 4649 + .map_err(|e| { 4650 4650 + tonic::Status::unknown( 4651 4651 + format!("Service was not ready: {}", e.into()), 4652 4652 + ) 4653 4653 + })?; 4032 4654 let codec = tonic::codec::ProstCodec::default(); 4033 4655 let path = http::uri::PathAndQuery::from_static( 4034 4656 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo", 4035 4657 ); 4036 4658 let mut req = request.into_request(); 4037 4037 - req.extensions_mut().insert(GrpcMethod::new( 4038 4038 - "rockbox.v1alpha1.PlaylistService", 4039 4039 - "GetTrackInfo", 4040 4040 - )); 4659 4659 + req.extensions_mut() 4660 4660 + .insert( 4661 4661 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetTrackInfo"), 4662 4662 + ); 4041 4663 self.inner.unary(req, path, codec).await 4042 4664 } 4043 4665 pub async fn get_first_index( 4044 4666 &mut self, 4045 4667 request: impl tonic::IntoRequest<super::GetFirstIndexRequest>, 4046 4046 - ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status> 4047 4047 - { 4048 4048 - self.inner.ready().await.map_err(|e| { 4049 4049 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4050 4050 - })?; 4668 4668 + ) -> std::result::Result< 4669 4669 + tonic::Response<super::GetFirstIndexResponse>, 4670 4670 + tonic::Status, 4671 4671 + > { 4672 4672 + self.inner 4673 4673 + .ready() 4674 4674 + .await 4675 4675 + .map_err(|e| { 4676 4676 + tonic::Status::unknown( 4677 4677 + format!("Service was not ready: {}", e.into()), 4678 4678 + ) 4679 4679 + })?; 4051 4680 let codec = tonic::codec::ProstCodec::default(); 4052 4681 let path = http::uri::PathAndQuery::from_static( 4053 4682 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex", 4054 4683 ); 4055 4684 let mut req = request.into_request(); 4056 4056 - req.extensions_mut().insert(GrpcMethod::new( 4057 4057 - "rockbox.v1alpha1.PlaylistService", 4058 4058 - "GetFirstIndex", 4059 4059 - )); 4685 4685 + req.extensions_mut() 4686 4686 + .insert( 4687 4687 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetFirstIndex"), 4688 4688 + ); 4060 4689 self.inner.unary(req, path, codec).await 4061 4690 } 4062 4691 pub async fn get_display_index( 4063 4692 &mut self, 4064 4693 request: impl tonic::IntoRequest<super::GetDisplayIndexRequest>, 4065 4065 - ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status> 4066 4066 - { 4067 4067 - self.inner.ready().await.map_err(|e| { 4068 4068 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4069 4069 - })?; 4694 4694 + ) -> std::result::Result< 4695 4695 + tonic::Response<super::GetDisplayIndexResponse>, 4696 4696 + tonic::Status, 4697 4697 + > { 4698 4698 + self.inner 4699 4699 + .ready() 4700 4700 + .await 4701 4701 + .map_err(|e| { 4702 4702 + tonic::Status::unknown( 4703 4703 + format!("Service was not ready: {}", e.into()), 4704 4704 + ) 4705 4705 + })?; 4070 4706 let codec = tonic::codec::ProstCodec::default(); 4071 4707 let path = http::uri::PathAndQuery::from_static( 4072 4708 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex", 4073 4709 ); 4074 4710 let mut req = request.into_request(); 4075 4075 - req.extensions_mut().insert(GrpcMethod::new( 4076 4076 - "rockbox.v1alpha1.PlaylistService", 4077 4077 - "GetDisplayIndex", 4078 4078 - )); 4711 4711 + req.extensions_mut() 4712 4712 + .insert( 4713 4713 + GrpcMethod::new( 4714 4714 + "rockbox.v1alpha1.PlaylistService", 4715 4715 + "GetDisplayIndex", 4716 4716 + ), 4717 4717 + ); 4079 4718 self.inner.unary(req, path, codec).await 4080 4719 } 4081 4720 pub async fn amount( 4082 4721 &mut self, 4083 4722 request: impl tonic::IntoRequest<super::AmountRequest>, 4084 4723 ) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status> { 4085 4085 - self.inner.ready().await.map_err(|e| { 4086 4086 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4087 4087 - })?; 4724 4724 + self.inner 4725 4725 + .ready() 4726 4726 + .await 4727 4727 + .map_err(|e| { 4728 4728 + tonic::Status::unknown( 4729 4729 + format!("Service was not ready: {}", e.into()), 4730 4730 + ) 4731 4731 + })?; 4088 4732 let codec = tonic::codec::ProstCodec::default(); 4089 4089 - let path = 4090 4090 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Amount"); 4733 4733 + let path = http::uri::PathAndQuery::from_static( 4734 4734 + "/rockbox.v1alpha1.PlaylistService/Amount", 4735 4735 + ); 4091 4736 let mut req = request.into_request(); 4092 4092 - req.extensions_mut().insert(GrpcMethod::new( 4093 4093 - "rockbox.v1alpha1.PlaylistService", 4094 4094 - "Amount", 4095 4095 - )); 4737 4737 + req.extensions_mut() 4738 4738 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Amount")); 4096 4739 self.inner.unary(req, path, codec).await 4097 4740 } 4098 4741 pub async fn playlist_resume( 4099 4742 &mut self, 4100 4743 request: impl tonic::IntoRequest<super::PlaylistResumeRequest>, 4101 4101 - ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status> 4102 4102 - { 4103 4103 - self.inner.ready().await.map_err(|e| { 4104 4104 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4105 4105 - })?; 4744 4744 + ) -> std::result::Result< 4745 4745 + tonic::Response<super::PlaylistResumeResponse>, 4746 4746 + tonic::Status, 4747 4747 + > { 4748 4748 + self.inner 4749 4749 + .ready() 4750 4750 + .await 4751 4751 + .map_err(|e| { 4752 4752 + tonic::Status::unknown( 4753 4753 + format!("Service was not ready: {}", e.into()), 4754 4754 + ) 4755 4755 + })?; 4106 4756 let codec = tonic::codec::ProstCodec::default(); 4107 4757 let path = http::uri::PathAndQuery::from_static( 4108 4758 "/rockbox.v1alpha1.PlaylistService/PlaylistResume", 4109 4759 ); 4110 4760 let mut req = request.into_request(); 4111 4111 - req.extensions_mut().insert(GrpcMethod::new( 4112 4112 - "rockbox.v1alpha1.PlaylistService", 4113 4113 - "PlaylistResume", 4114 4114 - )); 4761 4761 + req.extensions_mut() 4762 4762 + .insert( 4763 4763 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "PlaylistResume"), 4764 4764 + ); 4115 4765 self.inner.unary(req, path, codec).await 4116 4766 } 4117 4767 pub async fn resume_track( 4118 4768 &mut self, 4119 4769 request: impl tonic::IntoRequest<super::ResumeTrackRequest>, 4120 4120 - ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status> 4121 4121 - { 4122 4122 - self.inner.ready().await.map_err(|e| { 4123 4123 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4124 4124 - })?; 4770 4770 + ) -> std::result::Result< 4771 4771 + tonic::Response<super::ResumeTrackResponse>, 4772 4772 + tonic::Status, 4773 4773 + > { 4774 4774 + self.inner 4775 4775 + .ready() 4776 4776 + .await 4777 4777 + .map_err(|e| { 4778 4778 + tonic::Status::unknown( 4779 4779 + format!("Service was not ready: {}", e.into()), 4780 4780 + ) 4781 4781 + })?; 4125 4782 let codec = tonic::codec::ProstCodec::default(); 4126 4783 let path = http::uri::PathAndQuery::from_static( 4127 4784 "/rockbox.v1alpha1.PlaylistService/ResumeTrack", 4128 4785 ); 4129 4786 let mut req = request.into_request(); 4130 4130 - req.extensions_mut().insert(GrpcMethod::new( 4131 4131 - "rockbox.v1alpha1.PlaylistService", 4132 4132 - "ResumeTrack", 4133 4133 - )); 4787 4787 + req.extensions_mut() 4788 4788 + .insert( 4789 4789 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "ResumeTrack"), 4790 4790 + ); 4134 4791 self.inner.unary(req, path, codec).await 4135 4792 } 4136 4793 pub async fn set_modified( 4137 4794 &mut self, 4138 4795 request: impl tonic::IntoRequest<super::SetModifiedRequest>, 4139 4139 - ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status> 4140 4140 - { 4141 4141 - self.inner.ready().await.map_err(|e| { 4142 4142 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4143 4143 - })?; 4796 4796 + ) -> std::result::Result< 4797 4797 + tonic::Response<super::SetModifiedResponse>, 4798 4798 + tonic::Status, 4799 4799 + > { 4800 4800 + self.inner 4801 4801 + .ready() 4802 4802 + .await 4803 4803 + .map_err(|e| { 4804 4804 + tonic::Status::unknown( 4805 4805 + format!("Service was not ready: {}", e.into()), 4806 4806 + ) 4807 4807 + })?; 4144 4808 let codec = tonic::codec::ProstCodec::default(); 4145 4809 let path = http::uri::PathAndQuery::from_static( 4146 4810 "/rockbox.v1alpha1.PlaylistService/SetModified", 4147 4811 ); 4148 4812 let mut req = request.into_request(); 4149 4149 - req.extensions_mut().insert(GrpcMethod::new( 4150 4150 - "rockbox.v1alpha1.PlaylistService", 4151 4151 - "SetModified", 4152 4152 - )); 4813 4813 + req.extensions_mut() 4814 4814 + .insert( 4815 4815 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "SetModified"), 4816 4816 + ); 4153 4817 self.inner.unary(req, path, codec).await 4154 4818 } 4155 4819 pub async fn start( 4156 4820 &mut self, 4157 4821 request: impl tonic::IntoRequest<super::StartRequest>, 4158 4822 ) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status> { 4159 4159 - self.inner.ready().await.map_err(|e| { 4160 4160 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4161 4161 - })?; 4823 4823 + self.inner 4824 4824 + .ready() 4825 4825 + .await 4826 4826 + .map_err(|e| { 4827 4827 + tonic::Status::unknown( 4828 4828 + format!("Service was not ready: {}", e.into()), 4829 4829 + ) 4830 4830 + })?; 4162 4831 let codec = tonic::codec::ProstCodec::default(); 4163 4163 - let path = 4164 4164 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Start"); 4832 4832 + let path = http::uri::PathAndQuery::from_static( 4833 4833 + "/rockbox.v1alpha1.PlaylistService/Start", 4834 4834 + ); 4165 4835 let mut req = request.into_request(); 4166 4836 req.extensions_mut() 4167 4837 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Start")); ··· 4171 4841 &mut self, 4172 4842 request: impl tonic::IntoRequest<super::SyncRequest>, 4173 4843 ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> { 4174 4174 - self.inner.ready().await.map_err(|e| { 4175 4175 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4176 4176 - })?; 4844 4844 + self.inner 4845 4845 + .ready() 4846 4846 + .await 4847 4847 + .map_err(|e| { 4848 4848 + tonic::Status::unknown( 4849 4849 + format!("Service was not ready: {}", e.into()), 4850 4850 + ) 4851 4851 + })?; 4177 4852 let codec = tonic::codec::ProstCodec::default(); 4178 4178 - let path = 4179 4179 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Sync"); 4853 4853 + let path = http::uri::PathAndQuery::from_static( 4854 4854 + "/rockbox.v1alpha1.PlaylistService/Sync", 4855 4855 + ); 4180 4856 let mut req = request.into_request(); 4181 4857 req.extensions_mut() 4182 4858 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Sync")); ··· 4185 4861 pub async fn remove_all_tracks( 4186 4862 &mut self, 4187 4863 request: impl tonic::IntoRequest<super::RemoveAllTracksRequest>, 4188 4188 - ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status> 4189 4189 - { 4190 4190 - self.inner.ready().await.map_err(|e| { 4191 4191 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4192 4192 - })?; 4864 4864 + ) -> std::result::Result< 4865 4865 + tonic::Response<super::RemoveAllTracksResponse>, 4866 4866 + tonic::Status, 4867 4867 + > { 4868 4868 + self.inner 4869 4869 + .ready() 4870 4870 + .await 4871 4871 + .map_err(|e| { 4872 4872 + tonic::Status::unknown( 4873 4873 + format!("Service was not ready: {}", e.into()), 4874 4874 + ) 4875 4875 + })?; 4193 4876 let codec = tonic::codec::ProstCodec::default(); 4194 4877 let path = http::uri::PathAndQuery::from_static( 4195 4878 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks", 4196 4879 ); 4197 4880 let mut req = request.into_request(); 4198 4198 - req.extensions_mut().insert(GrpcMethod::new( 4199 4199 - "rockbox.v1alpha1.PlaylistService", 4200 4200 - "RemoveAllTracks", 4201 4201 - )); 4881 4881 + req.extensions_mut() 4882 4882 + .insert( 4883 4883 + GrpcMethod::new( 4884 4884 + "rockbox.v1alpha1.PlaylistService", 4885 4885 + "RemoveAllTracks", 4886 4886 + ), 4887 4887 + ); 4202 4888 self.inner.unary(req, path, codec).await 4203 4889 } 4204 4890 pub async fn remove_tracks( 4205 4891 &mut self, 4206 4892 request: impl tonic::IntoRequest<super::RemoveTracksRequest>, 4207 4207 - ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status> 4208 4208 - { 4209 4209 - self.inner.ready().await.map_err(|e| { 4210 4210 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4211 4211 - })?; 4893 4893 + ) -> std::result::Result< 4894 4894 + tonic::Response<super::RemoveTracksResponse>, 4895 4895 + tonic::Status, 4896 4896 + > { 4897 4897 + self.inner 4898 4898 + .ready() 4899 4899 + .await 4900 4900 + .map_err(|e| { 4901 4901 + tonic::Status::unknown( 4902 4902 + format!("Service was not ready: {}", e.into()), 4903 4903 + ) 4904 4904 + })?; 4212 4905 let codec = tonic::codec::ProstCodec::default(); 4213 4906 let path = http::uri::PathAndQuery::from_static( 4214 4907 "/rockbox.v1alpha1.PlaylistService/RemoveTracks", 4215 4908 ); 4216 4909 let mut req = request.into_request(); 4217 4217 - req.extensions_mut().insert(GrpcMethod::new( 4218 4218 - "rockbox.v1alpha1.PlaylistService", 4219 4219 - "RemoveTracks", 4220 4220 - )); 4910 4910 + req.extensions_mut() 4911 4911 + .insert( 4912 4912 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "RemoveTracks"), 4913 4913 + ); 4221 4914 self.inner.unary(req, path, codec).await 4222 4915 } 4223 4916 pub async fn create_playlist( 4224 4917 &mut self, 4225 4918 request: impl tonic::IntoRequest<super::CreatePlaylistRequest>, 4226 4226 - ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status> 4227 4227 - { 4228 4228 - self.inner.ready().await.map_err(|e| { 4229 4229 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4230 4230 - })?; 4919 4919 + ) -> std::result::Result< 4920 4920 + tonic::Response<super::CreatePlaylistResponse>, 4921 4921 + tonic::Status, 4922 4922 + > { 4923 4923 + self.inner 4924 4924 + .ready() 4925 4925 + .await 4926 4926 + .map_err(|e| { 4927 4927 + tonic::Status::unknown( 4928 4928 + format!("Service was not ready: {}", e.into()), 4929 4929 + ) 4930 4930 + })?; 4231 4931 let codec = tonic::codec::ProstCodec::default(); 4232 4932 let path = http::uri::PathAndQuery::from_static( 4233 4933 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist", 4234 4934 ); 4235 4935 let mut req = request.into_request(); 4236 4236 - req.extensions_mut().insert(GrpcMethod::new( 4237 4237 - "rockbox.v1alpha1.PlaylistService", 4238 4238 - "CreatePlaylist", 4239 4239 - )); 4936 4936 + req.extensions_mut() 4937 4937 + .insert( 4938 4938 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "CreatePlaylist"), 4939 4939 + ); 4240 4940 self.inner.unary(req, path, codec).await 4241 4941 } 4242 4942 pub async fn insert_tracks( 4243 4943 &mut self, 4244 4944 request: impl tonic::IntoRequest<super::InsertTracksRequest>, 4245 4245 - ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status> 4246 4246 - { 4247 4247 - self.inner.ready().await.map_err(|e| { 4248 4248 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4249 4249 - })?; 4945 4945 + ) -> std::result::Result< 4946 4946 + tonic::Response<super::InsertTracksResponse>, 4947 4947 + tonic::Status, 4948 4948 + > { 4949 4949 + self.inner 4950 4950 + .ready() 4951 4951 + .await 4952 4952 + .map_err(|e| { 4953 4953 + tonic::Status::unknown( 4954 4954 + format!("Service was not ready: {}", e.into()), 4955 4955 + ) 4956 4956 + })?; 4250 4957 let codec = tonic::codec::ProstCodec::default(); 4251 4958 let path = http::uri::PathAndQuery::from_static( 4252 4959 "/rockbox.v1alpha1.PlaylistService/InsertTracks", 4253 4960 ); 4254 4961 let mut req = request.into_request(); 4255 4255 - req.extensions_mut().insert(GrpcMethod::new( 4256 4256 - "rockbox.v1alpha1.PlaylistService", 4257 4257 - "InsertTracks", 4258 4258 - )); 4962 4962 + req.extensions_mut() 4963 4963 + .insert( 4964 4964 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertTracks"), 4965 4965 + ); 4259 4966 self.inner.unary(req, path, codec).await 4260 4967 } 4261 4968 pub async fn insert_directory( 4262 4969 &mut self, 4263 4970 request: impl tonic::IntoRequest<super::InsertDirectoryRequest>, 4264 4264 - ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status> 4265 4265 - { 4266 4266 - self.inner.ready().await.map_err(|e| { 4267 4267 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4268 4268 - })?; 4971 4971 + ) -> std::result::Result< 4972 4972 + tonic::Response<super::InsertDirectoryResponse>, 4973 4973 + tonic::Status, 4974 4974 + > { 4975 4975 + self.inner 4976 4976 + .ready() 4977 4977 + .await 4978 4978 + .map_err(|e| { 4979 4979 + tonic::Status::unknown( 4980 4980 + format!("Service was not ready: {}", e.into()), 4981 4981 + ) 4982 4982 + })?; 4269 4983 let codec = tonic::codec::ProstCodec::default(); 4270 4984 let path = http::uri::PathAndQuery::from_static( 4271 4985 "/rockbox.v1alpha1.PlaylistService/InsertDirectory", 4272 4986 ); 4273 4987 let mut req = request.into_request(); 4274 4274 - req.extensions_mut().insert(GrpcMethod::new( 4275 4275 - "rockbox.v1alpha1.PlaylistService", 4276 4276 - "InsertDirectory", 4277 4277 - )); 4988 4988 + req.extensions_mut() 4989 4989 + .insert( 4990 4990 + GrpcMethod::new( 4991 4991 + "rockbox.v1alpha1.PlaylistService", 4992 4992 + "InsertDirectory", 4993 4993 + ), 4994 4994 + ); 4278 4995 self.inner.unary(req, path, codec).await 4279 4996 } 4280 4997 pub async fn insert_playlist( 4281 4998 &mut self, 4282 4999 request: impl tonic::IntoRequest<super::InsertPlaylistRequest>, 4283 4283 - ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status> 4284 4284 - { 4285 4285 - self.inner.ready().await.map_err(|e| { 4286 4286 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4287 4287 - })?; 5000 5000 + ) -> std::result::Result< 5001 5001 + tonic::Response<super::InsertPlaylistResponse>, 5002 5002 + tonic::Status, 5003 5003 + > { 5004 5004 + self.inner 5005 5005 + .ready() 5006 5006 + .await 5007 5007 + .map_err(|e| { 5008 5008 + tonic::Status::unknown( 5009 5009 + format!("Service was not ready: {}", e.into()), 5010 5010 + ) 5011 5011 + })?; 4288 5012 let codec = tonic::codec::ProstCodec::default(); 4289 5013 let path = http::uri::PathAndQuery::from_static( 4290 5014 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist", 4291 5015 ); 4292 5016 let mut req = request.into_request(); 4293 4293 - req.extensions_mut().insert(GrpcMethod::new( 4294 4294 - "rockbox.v1alpha1.PlaylistService", 4295 4295 - "InsertPlaylist", 4296 4296 - )); 5017 5017 + req.extensions_mut() 5018 5018 + .insert( 5019 5019 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertPlaylist"), 5020 5020 + ); 4297 5021 self.inner.unary(req, path, codec).await 4298 5022 } 4299 5023 pub async fn insert_album( 4300 5024 &mut self, 4301 5025 request: impl tonic::IntoRequest<super::InsertAlbumRequest>, 4302 4302 - ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status> 4303 4303 - { 4304 4304 - self.inner.ready().await.map_err(|e| { 4305 4305 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4306 4306 - })?; 5026 5026 + ) -> std::result::Result< 5027 5027 + tonic::Response<super::InsertAlbumResponse>, 5028 5028 + tonic::Status, 5029 5029 + > { 5030 5030 + self.inner 5031 5031 + .ready() 5032 5032 + .await 5033 5033 + .map_err(|e| { 5034 5034 + tonic::Status::unknown( 5035 5035 + format!("Service was not ready: {}", e.into()), 5036 5036 + ) 5037 5037 + })?; 4307 5038 let codec = tonic::codec::ProstCodec::default(); 4308 5039 let path = http::uri::PathAndQuery::from_static( 4309 5040 "/rockbox.v1alpha1.PlaylistService/InsertAlbum", 4310 5041 ); 4311 5042 let mut req = request.into_request(); 4312 4312 - req.extensions_mut().insert(GrpcMethod::new( 4313 4313 - "rockbox.v1alpha1.PlaylistService", 4314 4314 - "InsertAlbum", 4315 4315 - )); 5043 5043 + req.extensions_mut() 5044 5044 + .insert( 5045 5045 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertAlbum"), 5046 5046 + ); 4316 5047 self.inner.unary(req, path, codec).await 4317 5048 } 4318 5049 pub async fn insert_artist_tracks( 4319 5050 &mut self, 4320 5051 request: impl tonic::IntoRequest<super::InsertArtistTracksRequest>, 4321 4321 - ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status> 4322 4322 - { 4323 4323 - self.inner.ready().await.map_err(|e| { 4324 4324 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4325 4325 - })?; 5052 5052 + ) -> std::result::Result< 5053 5053 + tonic::Response<super::InsertArtistTracksResponse>, 5054 5054 + tonic::Status, 5055 5055 + > { 5056 5056 + self.inner 5057 5057 + .ready() 5058 5058 + .await 5059 5059 + .map_err(|e| { 5060 5060 + tonic::Status::unknown( 5061 5061 + format!("Service was not ready: {}", e.into()), 5062 5062 + ) 5063 5063 + })?; 4326 5064 let codec = tonic::codec::ProstCodec::default(); 4327 5065 let path = http::uri::PathAndQuery::from_static( 4328 5066 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks", 4329 5067 ); 4330 5068 let mut req = request.into_request(); 4331 4331 - req.extensions_mut().insert(GrpcMethod::new( 4332 4332 - "rockbox.v1alpha1.PlaylistService", 4333 4333 - "InsertArtistTracks", 4334 4334 - )); 5069 5069 + req.extensions_mut() 5070 5070 + .insert( 5071 5071 + GrpcMethod::new( 5072 5072 + "rockbox.v1alpha1.PlaylistService", 5073 5073 + "InsertArtistTracks", 5074 5074 + ), 5075 5075 + ); 4335 5076 self.inner.unary(req, path, codec).await 4336 5077 } 4337 5078 pub async fn shuffle_playlist( 4338 5079 &mut self, 4339 5080 request: impl tonic::IntoRequest<super::ShufflePlaylistRequest>, 4340 4340 - ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status> 4341 4341 - { 4342 4342 - self.inner.ready().await.map_err(|e| { 4343 4343 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4344 4344 - })?; 5081 5081 + ) -> std::result::Result< 5082 5082 + tonic::Response<super::ShufflePlaylistResponse>, 5083 5083 + tonic::Status, 5084 5084 + > { 5085 5085 + self.inner 5086 5086 + .ready() 5087 5087 + .await 5088 5088 + .map_err(|e| { 5089 5089 + tonic::Status::unknown( 5090 5090 + format!("Service was not ready: {}", e.into()), 5091 5091 + ) 5092 5092 + })?; 4345 5093 let codec = tonic::codec::ProstCodec::default(); 4346 5094 let path = http::uri::PathAndQuery::from_static( 4347 5095 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist", 4348 5096 ); 4349 5097 let mut req = request.into_request(); 4350 4350 - req.extensions_mut().insert(GrpcMethod::new( 4351 4351 - "rockbox.v1alpha1.PlaylistService", 4352 4352 - "ShufflePlaylist", 4353 4353 - )); 5098 5098 + req.extensions_mut() 5099 5099 + .insert( 5100 5100 + GrpcMethod::new( 5101 5101 + "rockbox.v1alpha1.PlaylistService", 5102 5102 + "ShufflePlaylist", 5103 5103 + ), 5104 5104 + ); 4354 5105 self.inner.unary(req, path, codec).await 4355 5106 } 4356 5107 } ··· 4362 5113 dead_code, 4363 5114 missing_docs, 4364 5115 clippy::wildcard_imports, 4365 4365 - clippy::let_unit_value 5116 5116 + clippy::let_unit_value, 4366 5117 )] 4367 5118 use tonic::codegen::*; 4368 5119 /// Generated trait containing gRPC methods that should be implemented for use with PlaylistServiceServer. ··· 4371 5122 async fn get_current( 4372 5123 &self, 4373 5124 request: tonic::Request<super::GetCurrentRequest>, 4374 4374 - ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status>; 5125 5125 + ) -> std::result::Result< 5126 5126 + tonic::Response<super::GetCurrentResponse>, 5127 5127 + tonic::Status, 5128 5128 + >; 4375 5129 async fn get_resume_info( 4376 5130 &self, 4377 5131 request: tonic::Request<super::GetResumeInfoRequest>, 4378 4378 - ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status>; 5132 5132 + ) -> std::result::Result< 5133 5133 + tonic::Response<super::GetResumeInfoResponse>, 5134 5134 + tonic::Status, 5135 5135 + >; 4379 5136 async fn get_track_info( 4380 5137 &self, 4381 5138 request: tonic::Request<super::GetTrackInfoRequest>, 4382 4382 - ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status>; 5139 5139 + ) -> std::result::Result< 5140 5140 + tonic::Response<super::GetTrackInfoResponse>, 5141 5141 + tonic::Status, 5142 5142 + >; 4383 5143 async fn get_first_index( 4384 5144 &self, 4385 5145 request: tonic::Request<super::GetFirstIndexRequest>, 4386 4386 - ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status>; 5146 5146 + ) -> std::result::Result< 5147 5147 + tonic::Response<super::GetFirstIndexResponse>, 5148 5148 + tonic::Status, 5149 5149 + >; 4387 5150 async fn get_display_index( 4388 5151 &self, 4389 5152 request: tonic::Request<super::GetDisplayIndexRequest>, 4390 4390 - ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>; 5153 5153 + ) -> std::result::Result< 5154 5154 + tonic::Response<super::GetDisplayIndexResponse>, 5155 5155 + tonic::Status, 5156 5156 + >; 4391 5157 async fn amount( 4392 5158 &self, 4393 5159 request: tonic::Request<super::AmountRequest>, ··· 4395 5161 async fn playlist_resume( 4396 5162 &self, 4397 5163 request: tonic::Request<super::PlaylistResumeRequest>, 4398 4398 - ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status>; 5164 5164 + ) -> std::result::Result< 5165 5165 + tonic::Response<super::PlaylistResumeResponse>, 5166 5166 + tonic::Status, 5167 5167 + >; 4399 5168 async fn resume_track( 4400 5169 &self, 4401 5170 request: tonic::Request<super::ResumeTrackRequest>, 4402 4402 - ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status>; 5171 5171 + ) -> std::result::Result< 5172 5172 + tonic::Response<super::ResumeTrackResponse>, 5173 5173 + tonic::Status, 5174 5174 + >; 4403 5175 async fn set_modified( 4404 5176 &self, 4405 5177 request: tonic::Request<super::SetModifiedRequest>, 4406 4406 - ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>; 5178 5178 + ) -> std::result::Result< 5179 5179 + tonic::Response<super::SetModifiedResponse>, 5180 5180 + tonic::Status, 5181 5181 + >; 4407 5182 async fn start( 4408 5183 &self, 4409 5184 request: tonic::Request<super::StartRequest>, ··· 4415 5190 async fn remove_all_tracks( 4416 5191 &self, 4417 5192 request: tonic::Request<super::RemoveAllTracksRequest>, 4418 4418 - ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status>; 5193 5193 + ) -> std::result::Result< 5194 5194 + tonic::Response<super::RemoveAllTracksResponse>, 5195 5195 + tonic::Status, 5196 5196 + >; 4419 5197 async fn remove_tracks( 4420 5198 &self, 4421 5199 request: tonic::Request<super::RemoveTracksRequest>, 4422 4422 - ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status>; 5200 5200 + ) -> std::result::Result< 5201 5201 + tonic::Response<super::RemoveTracksResponse>, 5202 5202 + tonic::Status, 5203 5203 + >; 4423 5204 async fn create_playlist( 4424 5205 &self, 4425 5206 request: tonic::Request<super::CreatePlaylistRequest>, 4426 4426 - ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status>; 5207 5207 + ) -> std::result::Result< 5208 5208 + tonic::Response<super::CreatePlaylistResponse>, 5209 5209 + tonic::Status, 5210 5210 + >; 4427 5211 async fn insert_tracks( 4428 5212 &self, 4429 5213 request: tonic::Request<super::InsertTracksRequest>, 4430 4430 - ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status>; 5214 5214 + ) -> std::result::Result< 5215 5215 + tonic::Response<super::InsertTracksResponse>, 5216 5216 + tonic::Status, 5217 5217 + >; 4431 5218 async fn insert_directory( 4432 5219 &self, 4433 5220 request: tonic::Request<super::InsertDirectoryRequest>, 4434 4434 - ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status>; 5221 5221 + ) -> std::result::Result< 5222 5222 + tonic::Response<super::InsertDirectoryResponse>, 5223 5223 + tonic::Status, 5224 5224 + >; 4435 5225 async fn insert_playlist( 4436 5226 &self, 4437 5227 request: tonic::Request<super::InsertPlaylistRequest>, 4438 4438 - ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status>; 5228 5228 + ) -> std::result::Result< 5229 5229 + tonic::Response<super::InsertPlaylistResponse>, 5230 5230 + tonic::Status, 5231 5231 + >; 4439 5232 async fn insert_album( 4440 5233 &self, 4441 5234 request: tonic::Request<super::InsertAlbumRequest>, 4442 4442 - ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>; 5235 5235 + ) -> std::result::Result< 5236 5236 + tonic::Response<super::InsertAlbumResponse>, 5237 5237 + tonic::Status, 5238 5238 + >; 4443 5239 async fn insert_artist_tracks( 4444 5240 &self, 4445 5241 request: tonic::Request<super::InsertArtistTracksRequest>, 4446 4446 - ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>; 5242 5242 + ) -> std::result::Result< 5243 5243 + tonic::Response<super::InsertArtistTracksResponse>, 5244 5244 + tonic::Status, 5245 5245 + >; 4447 5246 async fn shuffle_playlist( 4448 5247 &self, 4449 5248 request: tonic::Request<super::ShufflePlaylistRequest>, 4450 4450 - ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>; 5249 5249 + ) -> std::result::Result< 5250 5250 + tonic::Response<super::ShufflePlaylistResponse>, 5251 5251 + tonic::Status, 5252 5252 + >; 4451 5253 } 4452 5254 #[derive(Debug)] 4453 5255 pub struct PlaylistServiceServer<T> { ··· 4470 5272 max_encoding_message_size: None, 4471 5273 } 4472 5274 } 4473 4473 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 5275 5275 + pub fn with_interceptor<F>( 5276 5276 + inner: T, 5277 5277 + interceptor: F, 5278 5278 + ) -> InterceptedService<Self, F> 4474 5279 where 4475 5280 F: tonic::service::Interceptor, 4476 5281 { ··· 4525 5330 "/rockbox.v1alpha1.PlaylistService/GetCurrent" => { 4526 5331 #[allow(non_camel_case_types)] 4527 5332 struct GetCurrentSvc<T: PlaylistService>(pub Arc<T>); 4528 4528 - impl<T: PlaylistService> tonic::server::UnaryService<super::GetCurrentRequest> 4529 4529 - for GetCurrentSvc<T> 4530 4530 - { 5333 5333 + impl< 5334 5334 + T: PlaylistService, 5335 5335 + > tonic::server::UnaryService<super::GetCurrentRequest> 5336 5336 + for GetCurrentSvc<T> { 4531 5337 type Response = super::GetCurrentResponse; 4532 4532 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5338 5338 + type Future = BoxFuture< 5339 5339 + tonic::Response<Self::Response>, 5340 5340 + tonic::Status, 5341 5341 + >; 4533 5342 fn call( 4534 5343 &mut self, 4535 5344 request: tonic::Request<super::GetCurrentRequest>, ··· 4566 5375 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo" => { 4567 5376 #[allow(non_camel_case_types)] 4568 5377 struct GetResumeInfoSvc<T: PlaylistService>(pub Arc<T>); 4569 4569 - impl<T: PlaylistService> 4570 4570 - tonic::server::UnaryService<super::GetResumeInfoRequest> 4571 4571 - for GetResumeInfoSvc<T> 4572 4572 - { 5378 5378 + impl< 5379 5379 + T: PlaylistService, 5380 5380 + > tonic::server::UnaryService<super::GetResumeInfoRequest> 5381 5381 + for GetResumeInfoSvc<T> { 4573 5382 type Response = super::GetResumeInfoResponse; 4574 4574 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5383 5383 + type Future = BoxFuture< 5384 5384 + tonic::Response<Self::Response>, 5385 5385 + tonic::Status, 5386 5386 + >; 4575 5387 fn call( 4576 5388 &mut self, 4577 5389 request: tonic::Request<super::GetResumeInfoRequest>, 4578 5390 ) -> Self::Future { 4579 5391 let inner = Arc::clone(&self.0); 4580 5392 let fut = async move { 4581 4581 - <T as PlaylistService>::get_resume_info(&inner, request).await 5393 5393 + <T as PlaylistService>::get_resume_info(&inner, request) 5394 5394 + .await 4582 5395 }; 4583 5396 Box::pin(fut) 4584 5397 } ··· 4608 5421 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo" => { 4609 5422 #[allow(non_camel_case_types)] 4610 5423 struct GetTrackInfoSvc<T: PlaylistService>(pub Arc<T>); 4611 4611 - impl<T: PlaylistService> tonic::server::UnaryService<super::GetTrackInfoRequest> 4612 4612 - for GetTrackInfoSvc<T> 4613 4613 - { 5424 5424 + impl< 5425 5425 + T: PlaylistService, 5426 5426 + > tonic::server::UnaryService<super::GetTrackInfoRequest> 5427 5427 + for GetTrackInfoSvc<T> { 4614 5428 type Response = super::GetTrackInfoResponse; 4615 4615 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5429 5429 + type Future = BoxFuture< 5430 5430 + tonic::Response<Self::Response>, 5431 5431 + tonic::Status, 5432 5432 + >; 4616 5433 fn call( 4617 5434 &mut self, 4618 5435 request: tonic::Request<super::GetTrackInfoRequest>, 4619 5436 ) -> Self::Future { 4620 5437 let inner = Arc::clone(&self.0); 4621 5438 let fut = async move { 4622 4622 - <T as PlaylistService>::get_track_info(&inner, request).await 5439 5439 + <T as PlaylistService>::get_track_info(&inner, request) 5440 5440 + .await 4623 5441 }; 4624 5442 Box::pin(fut) 4625 5443 } ··· 4649 5467 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex" => { 4650 5468 #[allow(non_camel_case_types)] 4651 5469 struct GetFirstIndexSvc<T: PlaylistService>(pub Arc<T>); 4652 4652 - impl<T: PlaylistService> 4653 4653 - tonic::server::UnaryService<super::GetFirstIndexRequest> 4654 4654 - for GetFirstIndexSvc<T> 4655 4655 - { 5470 5470 + impl< 5471 5471 + T: PlaylistService, 5472 5472 + > tonic::server::UnaryService<super::GetFirstIndexRequest> 5473 5473 + for GetFirstIndexSvc<T> { 4656 5474 type Response = super::GetFirstIndexResponse; 4657 4657 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5475 5475 + type Future = BoxFuture< 5476 5476 + tonic::Response<Self::Response>, 5477 5477 + tonic::Status, 5478 5478 + >; 4658 5479 fn call( 4659 5480 &mut self, 4660 5481 request: tonic::Request<super::GetFirstIndexRequest>, 4661 5482 ) -> Self::Future { 4662 5483 let inner = Arc::clone(&self.0); 4663 5484 let fut = async move { 4664 4664 - <T as PlaylistService>::get_first_index(&inner, request).await 5485 5485 + <T as PlaylistService>::get_first_index(&inner, request) 5486 5486 + .await 4665 5487 }; 4666 5488 Box::pin(fut) 4667 5489 } ··· 4691 5513 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex" => { 4692 5514 #[allow(non_camel_case_types)] 4693 5515 struct GetDisplayIndexSvc<T: PlaylistService>(pub Arc<T>); 4694 4694 - impl<T: PlaylistService> 4695 4695 - tonic::server::UnaryService<super::GetDisplayIndexRequest> 4696 4696 - for GetDisplayIndexSvc<T> 4697 4697 - { 5516 5516 + impl< 5517 5517 + T: PlaylistService, 5518 5518 + > tonic::server::UnaryService<super::GetDisplayIndexRequest> 5519 5519 + for GetDisplayIndexSvc<T> { 4698 5520 type Response = super::GetDisplayIndexResponse; 4699 4699 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5521 5521 + type Future = BoxFuture< 5522 5522 + tonic::Response<Self::Response>, 5523 5523 + tonic::Status, 5524 5524 + >; 4700 5525 fn call( 4701 5526 &mut self, 4702 5527 request: tonic::Request<super::GetDisplayIndexRequest>, 4703 5528 ) -> Self::Future { 4704 5529 let inner = Arc::clone(&self.0); 4705 5530 let fut = async move { 4706 4706 - <T as PlaylistService>::get_display_index(&inner, request).await 5531 5531 + <T as PlaylistService>::get_display_index(&inner, request) 5532 5532 + .await 4707 5533 }; 4708 5534 Box::pin(fut) 4709 5535 } ··· 4733 5559 "/rockbox.v1alpha1.PlaylistService/Amount" => { 4734 5560 #[allow(non_camel_case_types)] 4735 5561 struct AmountSvc<T: PlaylistService>(pub Arc<T>); 4736 4736 - impl<T: PlaylistService> tonic::server::UnaryService<super::AmountRequest> for AmountSvc<T> { 5562 5562 + impl< 5563 5563 + T: PlaylistService, 5564 5564 + > tonic::server::UnaryService<super::AmountRequest> 5565 5565 + for AmountSvc<T> { 4737 5566 type Response = super::AmountResponse; 4738 4738 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5567 5567 + type Future = BoxFuture< 5568 5568 + tonic::Response<Self::Response>, 5569 5569 + tonic::Status, 5570 5570 + >; 4739 5571 fn call( 4740 5572 &mut self, 4741 5573 request: tonic::Request<super::AmountRequest>, ··· 4772 5604 "/rockbox.v1alpha1.PlaylistService/PlaylistResume" => { 4773 5605 #[allow(non_camel_case_types)] 4774 5606 struct PlaylistResumeSvc<T: PlaylistService>(pub Arc<T>); 4775 4775 - impl<T: PlaylistService> 4776 4776 - tonic::server::UnaryService<super::PlaylistResumeRequest> 4777 4777 - for PlaylistResumeSvc<T> 4778 4778 - { 5607 5607 + impl< 5608 5608 + T: PlaylistService, 5609 5609 + > tonic::server::UnaryService<super::PlaylistResumeRequest> 5610 5610 + for PlaylistResumeSvc<T> { 4779 5611 type Response = super::PlaylistResumeResponse; 4780 4780 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5612 5612 + type Future = BoxFuture< 5613 5613 + tonic::Response<Self::Response>, 5614 5614 + tonic::Status, 5615 5615 + >; 4781 5616 fn call( 4782 5617 &mut self, 4783 5618 request: tonic::Request<super::PlaylistResumeRequest>, 4784 5619 ) -> Self::Future { 4785 5620 let inner = Arc::clone(&self.0); 4786 5621 let fut = async move { 4787 4787 - <T as PlaylistService>::playlist_resume(&inner, request).await 5622 5622 + <T as PlaylistService>::playlist_resume(&inner, request) 5623 5623 + .await 4788 5624 }; 4789 5625 Box::pin(fut) 4790 5626 } ··· 4814 5650 "/rockbox.v1alpha1.PlaylistService/ResumeTrack" => { 4815 5651 #[allow(non_camel_case_types)] 4816 5652 struct ResumeTrackSvc<T: PlaylistService>(pub Arc<T>); 4817 4817 - impl<T: PlaylistService> tonic::server::UnaryService<super::ResumeTrackRequest> 4818 4818 - for ResumeTrackSvc<T> 4819 4819 - { 5653 5653 + impl< 5654 5654 + T: PlaylistService, 5655 5655 + > tonic::server::UnaryService<super::ResumeTrackRequest> 5656 5656 + for ResumeTrackSvc<T> { 4820 5657 type Response = super::ResumeTrackResponse; 4821 4821 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5658 5658 + type Future = BoxFuture< 5659 5659 + tonic::Response<Self::Response>, 5660 5660 + tonic::Status, 5661 5661 + >; 4822 5662 fn call( 4823 5663 &mut self, 4824 5664 request: tonic::Request<super::ResumeTrackRequest>, ··· 4855 5695 "/rockbox.v1alpha1.PlaylistService/SetModified" => { 4856 5696 #[allow(non_camel_case_types)] 4857 5697 struct SetModifiedSvc<T: PlaylistService>(pub Arc<T>); 4858 4858 - impl<T: PlaylistService> tonic::server::UnaryService<super::SetModifiedRequest> 4859 4859 - for SetModifiedSvc<T> 4860 4860 - { 5698 5698 + impl< 5699 5699 + T: PlaylistService, 5700 5700 + > tonic::server::UnaryService<super::SetModifiedRequest> 5701 5701 + for SetModifiedSvc<T> { 4861 5702 type Response = super::SetModifiedResponse; 4862 4862 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5703 5703 + type Future = BoxFuture< 5704 5704 + tonic::Response<Self::Response>, 5705 5705 + tonic::Status, 5706 5706 + >; 4863 5707 fn call( 4864 5708 &mut self, 4865 5709 request: tonic::Request<super::SetModifiedRequest>, ··· 4896 5740 "/rockbox.v1alpha1.PlaylistService/Start" => { 4897 5741 #[allow(non_camel_case_types)] 4898 5742 struct StartSvc<T: PlaylistService>(pub Arc<T>); 4899 4899 - impl<T: PlaylistService> tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 5743 5743 + impl< 5744 5744 + T: PlaylistService, 5745 5745 + > tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 4900 5746 type Response = super::StartResponse; 4901 4901 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5747 5747 + type Future = BoxFuture< 5748 5748 + tonic::Response<Self::Response>, 5749 5749 + tonic::Status, 5750 5750 + >; 4902 5751 fn call( 4903 5752 &mut self, 4904 5753 request: tonic::Request<super::StartRequest>, 4905 5754 ) -> Self::Future { 4906 5755 let inner = Arc::clone(&self.0); 4907 4907 - let fut = 4908 4908 - async move { <T as PlaylistService>::start(&inner, request).await }; 5756 5756 + let fut = async move { 5757 5757 + <T as PlaylistService>::start(&inner, request).await 5758 5758 + }; 4909 5759 Box::pin(fut) 4910 5760 } 4911 5761 } ··· 4934 5784 "/rockbox.v1alpha1.PlaylistService/Sync" => { 4935 5785 #[allow(non_camel_case_types)] 4936 5786 struct SyncSvc<T: PlaylistService>(pub Arc<T>); 4937 4937 - impl<T: PlaylistService> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 5787 5787 + impl< 5788 5788 + T: PlaylistService, 5789 5789 + > tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 4938 5790 type Response = super::SyncResponse; 4939 4939 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5791 5791 + type Future = BoxFuture< 5792 5792 + tonic::Response<Self::Response>, 5793 5793 + tonic::Status, 5794 5794 + >; 4940 5795 fn call( 4941 5796 &mut self, 4942 5797 request: tonic::Request<super::SyncRequest>, 4943 5798 ) -> Self::Future { 4944 5799 let inner = Arc::clone(&self.0); 4945 4945 - let fut = 4946 4946 - async move { <T as PlaylistService>::sync(&inner, request).await }; 5800 5800 + let fut = async move { 5801 5801 + <T as PlaylistService>::sync(&inner, request).await 5802 5802 + }; 4947 5803 Box::pin(fut) 4948 5804 } 4949 5805 } ··· 4972 5828 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks" => { 4973 5829 #[allow(non_camel_case_types)] 4974 5830 struct RemoveAllTracksSvc<T: PlaylistService>(pub Arc<T>); 4975 4975 - impl<T: PlaylistService> 4976 4976 - tonic::server::UnaryService<super::RemoveAllTracksRequest> 4977 4977 - for RemoveAllTracksSvc<T> 4978 4978 - { 5831 5831 + impl< 5832 5832 + T: PlaylistService, 5833 5833 + > tonic::server::UnaryService<super::RemoveAllTracksRequest> 5834 5834 + for RemoveAllTracksSvc<T> { 4979 5835 type Response = super::RemoveAllTracksResponse; 4980 4980 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5836 5836 + type Future = BoxFuture< 5837 5837 + tonic::Response<Self::Response>, 5838 5838 + tonic::Status, 5839 5839 + >; 4981 5840 fn call( 4982 5841 &mut self, 4983 5842 request: tonic::Request<super::RemoveAllTracksRequest>, 4984 5843 ) -> Self::Future { 4985 5844 let inner = Arc::clone(&self.0); 4986 5845 let fut = async move { 4987 4987 - <T as PlaylistService>::remove_all_tracks(&inner, request).await 5846 5846 + <T as PlaylistService>::remove_all_tracks(&inner, request) 5847 5847 + .await 4988 5848 }; 4989 5849 Box::pin(fut) 4990 5850 } ··· 5014 5874 "/rockbox.v1alpha1.PlaylistService/RemoveTracks" => { 5015 5875 #[allow(non_camel_case_types)] 5016 5876 struct RemoveTracksSvc<T: PlaylistService>(pub Arc<T>); 5017 5017 - impl<T: PlaylistService> tonic::server::UnaryService<super::RemoveTracksRequest> 5018 5018 - for RemoveTracksSvc<T> 5019 5019 - { 5877 5877 + impl< 5878 5878 + T: PlaylistService, 5879 5879 + > tonic::server::UnaryService<super::RemoveTracksRequest> 5880 5880 + for RemoveTracksSvc<T> { 5020 5881 type Response = super::RemoveTracksResponse; 5021 5021 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5882 5882 + type Future = BoxFuture< 5883 5883 + tonic::Response<Self::Response>, 5884 5884 + tonic::Status, 5885 5885 + >; 5022 5886 fn call( 5023 5887 &mut self, 5024 5888 request: tonic::Request<super::RemoveTracksRequest>, ··· 5055 5919 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist" => { 5056 5920 #[allow(non_camel_case_types)] 5057 5921 struct CreatePlaylistSvc<T: PlaylistService>(pub Arc<T>); 5058 5058 - impl<T: PlaylistService> 5059 5059 - tonic::server::UnaryService<super::CreatePlaylistRequest> 5060 5060 - for CreatePlaylistSvc<T> 5061 5061 - { 5922 5922 + impl< 5923 5923 + T: PlaylistService, 5924 5924 + > tonic::server::UnaryService<super::CreatePlaylistRequest> 5925 5925 + for CreatePlaylistSvc<T> { 5062 5926 type Response = super::CreatePlaylistResponse; 5063 5063 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5927 5927 + type Future = BoxFuture< 5928 5928 + tonic::Response<Self::Response>, 5929 5929 + tonic::Status, 5930 5930 + >; 5064 5931 fn call( 5065 5932 &mut self, 5066 5933 request: tonic::Request<super::CreatePlaylistRequest>, 5067 5934 ) -> Self::Future { 5068 5935 let inner = Arc::clone(&self.0); 5069 5936 let fut = async move { 5070 5070 - <T as PlaylistService>::create_playlist(&inner, request).await 5937 5937 + <T as PlaylistService>::create_playlist(&inner, request) 5938 5938 + .await 5071 5939 }; 5072 5940 Box::pin(fut) 5073 5941 } ··· 5097 5965 "/rockbox.v1alpha1.PlaylistService/InsertTracks" => { 5098 5966 #[allow(non_camel_case_types)] 5099 5967 struct InsertTracksSvc<T: PlaylistService>(pub Arc<T>); 5100 5100 - impl<T: PlaylistService> tonic::server::UnaryService<super::InsertTracksRequest> 5101 5101 - for InsertTracksSvc<T> 5102 5102 - { 5968 5968 + impl< 5969 5969 + T: PlaylistService, 5970 5970 + > tonic::server::UnaryService<super::InsertTracksRequest> 5971 5971 + for InsertTracksSvc<T> { 5103 5972 type Response = super::InsertTracksResponse; 5104 5104 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5973 5973 + type Future = BoxFuture< 5974 5974 + tonic::Response<Self::Response>, 5975 5975 + tonic::Status, 5976 5976 + >; 5105 5977 fn call( 5106 5978 &mut self, 5107 5979 request: tonic::Request<super::InsertTracksRequest>, ··· 5138 6010 "/rockbox.v1alpha1.PlaylistService/InsertDirectory" => { 5139 6011 #[allow(non_camel_case_types)] 5140 6012 struct InsertDirectorySvc<T: PlaylistService>(pub Arc<T>); 5141 5141 - impl<T: PlaylistService> 5142 5142 - tonic::server::UnaryService<super::InsertDirectoryRequest> 5143 5143 - for InsertDirectorySvc<T> 5144 5144 - { 6013 6013 + impl< 6014 6014 + T: PlaylistService, 6015 6015 + > tonic::server::UnaryService<super::InsertDirectoryRequest> 6016 6016 + for InsertDirectorySvc<T> { 5145 6017 type Response = super::InsertDirectoryResponse; 5146 5146 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6018 6018 + type Future = BoxFuture< 6019 6019 + tonic::Response<Self::Response>, 6020 6020 + tonic::Status, 6021 6021 + >; 5147 6022 fn call( 5148 6023 &mut self, 5149 6024 request: tonic::Request<super::InsertDirectoryRequest>, 5150 6025 ) -> Self::Future { 5151 6026 let inner = Arc::clone(&self.0); 5152 6027 let fut = async move { 5153 5153 - <T as PlaylistService>::insert_directory(&inner, request).await 6028 6028 + <T as PlaylistService>::insert_directory(&inner, request) 6029 6029 + .await 5154 6030 }; 5155 6031 Box::pin(fut) 5156 6032 } ··· 5180 6056 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist" => { 5181 6057 #[allow(non_camel_case_types)] 5182 6058 struct InsertPlaylistSvc<T: PlaylistService>(pub Arc<T>); 5183 5183 - impl<T: PlaylistService> 5184 5184 - tonic::server::UnaryService<super::InsertPlaylistRequest> 5185 5185 - for InsertPlaylistSvc<T> 5186 5186 - { 6059 6059 + impl< 6060 6060 + T: PlaylistService, 6061 6061 + > tonic::server::UnaryService<super::InsertPlaylistRequest> 6062 6062 + for InsertPlaylistSvc<T> { 5187 6063 type Response = super::InsertPlaylistResponse; 5188 5188 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6064 6064 + type Future = BoxFuture< 6065 6065 + tonic::Response<Self::Response>, 6066 6066 + tonic::Status, 6067 6067 + >; 5189 6068 fn call( 5190 6069 &mut self, 5191 6070 request: tonic::Request<super::InsertPlaylistRequest>, 5192 6071 ) -> Self::Future { 5193 6072 let inner = Arc::clone(&self.0); 5194 6073 let fut = async move { 5195 5195 - <T as PlaylistService>::insert_playlist(&inner, request).await 6074 6074 + <T as PlaylistService>::insert_playlist(&inner, request) 6075 6075 + .await 5196 6076 }; 5197 6077 Box::pin(fut) 5198 6078 } ··· 5222 6102 "/rockbox.v1alpha1.PlaylistService/InsertAlbum" => { 5223 6103 #[allow(non_camel_case_types)] 5224 6104 struct InsertAlbumSvc<T: PlaylistService>(pub Arc<T>); 5225 5225 - impl<T: PlaylistService> tonic::server::UnaryService<super::InsertAlbumRequest> 5226 5226 - for InsertAlbumSvc<T> 5227 5227 - { 6105 6105 + impl< 6106 6106 + T: PlaylistService, 6107 6107 + > tonic::server::UnaryService<super::InsertAlbumRequest> 6108 6108 + for InsertAlbumSvc<T> { 5228 6109 type Response = super::InsertAlbumResponse; 5229 5229 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6110 6110 + type Future = BoxFuture< 6111 6111 + tonic::Response<Self::Response>, 6112 6112 + tonic::Status, 6113 6113 + >; 5230 6114 fn call( 5231 6115 &mut self, 5232 6116 request: tonic::Request<super::InsertAlbumRequest>, ··· 5263 6147 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks" => { 5264 6148 #[allow(non_camel_case_types)] 5265 6149 struct InsertArtistTracksSvc<T: PlaylistService>(pub Arc<T>); 5266 5266 - impl<T: PlaylistService> 5267 5267 - tonic::server::UnaryService<super::InsertArtistTracksRequest> 5268 5268 - for InsertArtistTracksSvc<T> 5269 5269 - { 6150 6150 + impl< 6151 6151 + T: PlaylistService, 6152 6152 + > tonic::server::UnaryService<super::InsertArtistTracksRequest> 6153 6153 + for InsertArtistTracksSvc<T> { 5270 6154 type Response = super::InsertArtistTracksResponse; 5271 5271 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6155 6155 + type Future = BoxFuture< 6156 6156 + tonic::Response<Self::Response>, 6157 6157 + tonic::Status, 6158 6158 + >; 5272 6159 fn call( 5273 6160 &mut self, 5274 6161 request: tonic::Request<super::InsertArtistTracksRequest>, 5275 6162 ) -> Self::Future { 5276 6163 let inner = Arc::clone(&self.0); 5277 6164 let fut = async move { 5278 5278 - <T as PlaylistService>::insert_artist_tracks(&inner, request).await 6165 6165 + <T as PlaylistService>::insert_artist_tracks( 6166 6166 + &inner, 6167 6167 + request, 6168 6168 + ) 6169 6169 + .await 5279 6170 }; 5280 6171 Box::pin(fut) 5281 6172 } ··· 5305 6196 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist" => { 5306 6197 #[allow(non_camel_case_types)] 5307 6198 struct ShufflePlaylistSvc<T: PlaylistService>(pub Arc<T>); 5308 5308 - impl<T: PlaylistService> 5309 5309 - tonic::server::UnaryService<super::ShufflePlaylistRequest> 5310 5310 - for ShufflePlaylistSvc<T> 5311 5311 - { 6199 6199 + impl< 6200 6200 + T: PlaylistService, 6201 6201 + > tonic::server::UnaryService<super::ShufflePlaylistRequest> 6202 6202 + for ShufflePlaylistSvc<T> { 5312 6203 type Response = super::ShufflePlaylistResponse; 5313 5313 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6204 6204 + type Future = BoxFuture< 6205 6205 + tonic::Response<Self::Response>, 6206 6206 + tonic::Status, 6207 6207 + >; 5314 6208 fn call( 5315 6209 &mut self, 5316 6210 request: tonic::Request<super::ShufflePlaylistRequest>, 5317 6211 ) -> Self::Future { 5318 6212 let inner = Arc::clone(&self.0); 5319 6213 let fut = async move { 5320 5320 - <T as PlaylistService>::shuffle_playlist(&inner, request).await 6214 6214 + <T as PlaylistService>::shuffle_playlist(&inner, request) 6215 6215 + .await 5321 6216 }; 5322 6217 Box::pin(fut) 5323 6218 } ··· 5344 6239 }; 5345 6240 Box::pin(fut) 5346 6241 } 5347 5347 - _ => Box::pin(async move { 5348 5348 - let mut response = http::Response::new(empty_body()); 5349 5349 - let headers = response.headers_mut(); 5350 5350 - headers.insert( 5351 5351 - tonic::Status::GRPC_STATUS, 5352 5352 - (tonic::Code::Unimplemented as i32).into(), 5353 5353 - ); 5354 5354 - headers.insert( 5355 5355 - http::header::CONTENT_TYPE, 5356 5356 - tonic::metadata::GRPC_CONTENT_TYPE, 5357 5357 - ); 5358 5358 - Ok(response) 5359 5359 - }), 6242 6242 + _ => { 6243 6243 + Box::pin(async move { 6244 6244 + let mut response = http::Response::new(empty_body()); 6245 6245 + let headers = response.headers_mut(); 6246 6246 + headers 6247 6247 + .insert( 6248 6248 + tonic::Status::GRPC_STATUS, 6249 6249 + (tonic::Code::Unimplemented as i32).into(), 6250 6250 + ); 6251 6251 + headers 6252 6252 + .insert( 6253 6253 + http::header::CONTENT_TYPE, 6254 6254 + tonic::metadata::GRPC_CONTENT_TYPE, 6255 6255 + ); 6256 6256 + Ok(response) 6257 6257 + }) 6258 6258 + } 5360 6259 } 5361 6260 } 5362 6261 } ··· 5864 6763 dead_code, 5865 6764 missing_docs, 5866 6765 clippy::wildcard_imports, 5867 5867 - clippy::let_unit_value 6766 6766 + clippy::let_unit_value, 5868 6767 )] 5869 5869 - use tonic::codegen::http::Uri; 5870 6768 use tonic::codegen::*; 6769 6769 + use tonic::codegen::http::Uri; 5871 6770 #[derive(Debug, Clone)] 5872 6771 pub struct SettingsServiceClient<T> { 5873 6772 inner: tonic::client::Grpc<T>, ··· 5911 6810 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 5912 6811 >, 5913 6812 >, 5914 5914 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 5915 5915 - Into<StdError> + std::marker::Send + std::marker::Sync, 6813 6813 + <T as tonic::codegen::Service< 6814 6814 + http::Request<tonic::body::BoxBody>, 6815 6815 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 5916 6816 { 5917 6817 SettingsServiceClient::new(InterceptedService::new(inner, interceptor)) 5918 6818 } ··· 5950 6850 pub async fn get_settings_list( 5951 6851 &mut self, 5952 6852 request: impl tonic::IntoRequest<super::GetSettingsListRequest>, 5953 5953 - ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status> 5954 5954 - { 5955 5955 - self.inner.ready().await.map_err(|e| { 5956 5956 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 5957 5957 - })?; 6853 6853 + ) -> std::result::Result< 6854 6854 + tonic::Response<super::GetSettingsListResponse>, 6855 6855 + tonic::Status, 6856 6856 + > { 6857 6857 + self.inner 6858 6858 + .ready() 6859 6859 + .await 6860 6860 + .map_err(|e| { 6861 6861 + tonic::Status::unknown( 6862 6862 + format!("Service was not ready: {}", e.into()), 6863 6863 + ) 6864 6864 + })?; 5958 6865 let codec = tonic::codec::ProstCodec::default(); 5959 6866 let path = http::uri::PathAndQuery::from_static( 5960 6867 "/rockbox.v1alpha1.SettingsService/GetSettingsList", 5961 6868 ); 5962 6869 let mut req = request.into_request(); 5963 5963 - req.extensions_mut().insert(GrpcMethod::new( 5964 5964 - "rockbox.v1alpha1.SettingsService", 5965 5965 - "GetSettingsList", 5966 5966 - )); 6870 6870 + req.extensions_mut() 6871 6871 + .insert( 6872 6872 + GrpcMethod::new( 6873 6873 + "rockbox.v1alpha1.SettingsService", 6874 6874 + "GetSettingsList", 6875 6875 + ), 6876 6876 + ); 5967 6877 self.inner.unary(req, path, codec).await 5968 6878 } 5969 6879 pub async fn get_global_settings( 5970 6880 &mut self, 5971 6881 request: impl tonic::IntoRequest<super::GetGlobalSettingsRequest>, 5972 5972 - ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status> 5973 5973 - { 5974 5974 - self.inner.ready().await.map_err(|e| { 5975 5975 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 5976 5976 - })?; 6882 6882 + ) -> std::result::Result< 6883 6883 + tonic::Response<super::GetGlobalSettingsResponse>, 6884 6884 + tonic::Status, 6885 6885 + > { 6886 6886 + self.inner 6887 6887 + .ready() 6888 6888 + .await 6889 6889 + .map_err(|e| { 6890 6890 + tonic::Status::unknown( 6891 6891 + format!("Service was not ready: {}", e.into()), 6892 6892 + ) 6893 6893 + })?; 5977 6894 let codec = tonic::codec::ProstCodec::default(); 5978 6895 let path = http::uri::PathAndQuery::from_static( 5979 6896 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings", 5980 6897 ); 5981 6898 let mut req = request.into_request(); 5982 5982 - req.extensions_mut().insert(GrpcMethod::new( 5983 5983 - "rockbox.v1alpha1.SettingsService", 5984 5984 - "GetGlobalSettings", 5985 5985 - )); 6899 6899 + req.extensions_mut() 6900 6900 + .insert( 6901 6901 + GrpcMethod::new( 6902 6902 + "rockbox.v1alpha1.SettingsService", 6903 6903 + "GetGlobalSettings", 6904 6904 + ), 6905 6905 + ); 5986 6906 self.inner.unary(req, path, codec).await 5987 6907 } 5988 6908 pub async fn save_settings( 5989 6909 &mut self, 5990 6910 request: impl tonic::IntoRequest<super::SaveSettingsRequest>, 5991 5991 - ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status> 5992 5992 - { 5993 5993 - self.inner.ready().await.map_err(|e| { 5994 5994 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 5995 5995 - })?; 6911 6911 + ) -> std::result::Result< 6912 6912 + tonic::Response<super::SaveSettingsResponse>, 6913 6913 + tonic::Status, 6914 6914 + > { 6915 6915 + self.inner 6916 6916 + .ready() 6917 6917 + .await 6918 6918 + .map_err(|e| { 6919 6919 + tonic::Status::unknown( 6920 6920 + format!("Service was not ready: {}", e.into()), 6921 6921 + ) 6922 6922 + })?; 5996 6923 let codec = tonic::codec::ProstCodec::default(); 5997 6924 let path = http::uri::PathAndQuery::from_static( 5998 6925 "/rockbox.v1alpha1.SettingsService/SaveSettings", 5999 6926 ); 6000 6927 let mut req = request.into_request(); 6001 6001 - req.extensions_mut().insert(GrpcMethod::new( 6002 6002 - "rockbox.v1alpha1.SettingsService", 6003 6003 - "SaveSettings", 6004 6004 - )); 6928 6928 + req.extensions_mut() 6929 6929 + .insert( 6930 6930 + GrpcMethod::new("rockbox.v1alpha1.SettingsService", "SaveSettings"), 6931 6931 + ); 6005 6932 self.inner.unary(req, path, codec).await 6006 6933 } 6007 6934 } ··· 6013 6940 dead_code, 6014 6941 missing_docs, 6015 6942 clippy::wildcard_imports, 6016 6016 - clippy::let_unit_value 6943 6943 + clippy::let_unit_value, 6017 6944 )] 6018 6945 use tonic::codegen::*; 6019 6946 /// Generated trait containing gRPC methods that should be implemented for use with SettingsServiceServer. ··· 6022 6949 async fn get_settings_list( 6023 6950 &self, 6024 6951 request: tonic::Request<super::GetSettingsListRequest>, 6025 6025 - ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status>; 6952 6952 + ) -> std::result::Result< 6953 6953 + tonic::Response<super::GetSettingsListResponse>, 6954 6954 + tonic::Status, 6955 6955 + >; 6026 6956 async fn get_global_settings( 6027 6957 &self, 6028 6958 request: tonic::Request<super::GetGlobalSettingsRequest>, 6029 6029 - ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status>; 6959 6959 + ) -> std::result::Result< 6960 6960 + tonic::Response<super::GetGlobalSettingsResponse>, 6961 6961 + tonic::Status, 6962 6962 + >; 6030 6963 async fn save_settings( 6031 6964 &self, 6032 6965 request: tonic::Request<super::SaveSettingsRequest>, 6033 6033 - ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>; 6966 6966 + ) -> std::result::Result< 6967 6967 + tonic::Response<super::SaveSettingsResponse>, 6968 6968 + tonic::Status, 6969 6969 + >; 6034 6970 } 6035 6971 #[derive(Debug)] 6036 6972 pub struct SettingsServiceServer<T> { ··· 6053 6989 max_encoding_message_size: None, 6054 6990 } 6055 6991 } 6056 6056 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 6992 6992 + pub fn with_interceptor<F>( 6993 6993 + inner: T, 6994 6994 + interceptor: F, 6995 6995 + ) -> InterceptedService<Self, F> 6057 6996 where 6058 6997 F: tonic::service::Interceptor, 6059 6998 { ··· 6108 7047 "/rockbox.v1alpha1.SettingsService/GetSettingsList" => { 6109 7048 #[allow(non_camel_case_types)] 6110 7049 struct GetSettingsListSvc<T: SettingsService>(pub Arc<T>); 6111 6111 - impl<T: SettingsService> 6112 6112 - tonic::server::UnaryService<super::GetSettingsListRequest> 6113 6113 - for GetSettingsListSvc<T> 6114 6114 - { 7050 7050 + impl< 7051 7051 + T: SettingsService, 7052 7052 + > tonic::server::UnaryService<super::GetSettingsListRequest> 7053 7053 + for GetSettingsListSvc<T> { 6115 7054 type Response = super::GetSettingsListResponse; 6116 6116 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7055 7055 + type Future = BoxFuture< 7056 7056 + tonic::Response<Self::Response>, 7057 7057 + tonic::Status, 7058 7058 + >; 6117 7059 fn call( 6118 7060 &mut self, 6119 7061 request: tonic::Request<super::GetSettingsListRequest>, 6120 7062 ) -> Self::Future { 6121 7063 let inner = Arc::clone(&self.0); 6122 7064 let fut = async move { 6123 6123 - <T as SettingsService>::get_settings_list(&inner, request).await 7065 7065 + <T as SettingsService>::get_settings_list(&inner, request) 7066 7066 + .await 6124 7067 }; 6125 7068 Box::pin(fut) 6126 7069 } ··· 6150 7093 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings" => { 6151 7094 #[allow(non_camel_case_types)] 6152 7095 struct GetGlobalSettingsSvc<T: SettingsService>(pub Arc<T>); 6153 6153 - impl<T: SettingsService> 6154 6154 - tonic::server::UnaryService<super::GetGlobalSettingsRequest> 6155 6155 - for GetGlobalSettingsSvc<T> 6156 6156 - { 7096 7096 + impl< 7097 7097 + T: SettingsService, 7098 7098 + > tonic::server::UnaryService<super::GetGlobalSettingsRequest> 7099 7099 + for GetGlobalSettingsSvc<T> { 6157 7100 type Response = super::GetGlobalSettingsResponse; 6158 6158 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7101 7101 + type Future = BoxFuture< 7102 7102 + tonic::Response<Self::Response>, 7103 7103 + tonic::Status, 7104 7104 + >; 6159 7105 fn call( 6160 7106 &mut self, 6161 7107 request: tonic::Request<super::GetGlobalSettingsRequest>, 6162 7108 ) -> Self::Future { 6163 7109 let inner = Arc::clone(&self.0); 6164 7110 let fut = async move { 6165 6165 - <T as SettingsService>::get_global_settings(&inner, request).await 7111 7111 + <T as SettingsService>::get_global_settings(&inner, request) 7112 7112 + .await 6166 7113 }; 6167 7114 Box::pin(fut) 6168 7115 } ··· 6192 7139 "/rockbox.v1alpha1.SettingsService/SaveSettings" => { 6193 7140 #[allow(non_camel_case_types)] 6194 7141 struct SaveSettingsSvc<T: SettingsService>(pub Arc<T>); 6195 6195 - impl<T: SettingsService> tonic::server::UnaryService<super::SaveSettingsRequest> 6196 6196 - for SaveSettingsSvc<T> 6197 6197 - { 7142 7142 + impl< 7143 7143 + T: SettingsService, 7144 7144 + > tonic::server::UnaryService<super::SaveSettingsRequest> 7145 7145 + for SaveSettingsSvc<T> { 6198 7146 type Response = super::SaveSettingsResponse; 6199 6199 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7147 7147 + type Future = BoxFuture< 7148 7148 + tonic::Response<Self::Response>, 7149 7149 + tonic::Status, 7150 7150 + >; 6200 7151 fn call( 6201 7152 &mut self, 6202 7153 request: tonic::Request<super::SaveSettingsRequest>, ··· 6230 7181 }; 6231 7182 Box::pin(fut) 6232 7183 } 6233 6233 - _ => Box::pin(async move { 6234 6234 - let mut response = http::Response::new(empty_body()); 6235 6235 - let headers = response.headers_mut(); 6236 6236 - headers.insert( 6237 6237 - tonic::Status::GRPC_STATUS, 6238 6238 - (tonic::Code::Unimplemented as i32).into(), 6239 6239 - ); 6240 6240 - headers.insert( 6241 6241 - http::header::CONTENT_TYPE, 6242 6242 - tonic::metadata::GRPC_CONTENT_TYPE, 6243 6243 - ); 6244 6244 - Ok(response) 6245 6245 - }), 7184 7184 + _ => { 7185 7185 + Box::pin(async move { 7186 7186 + let mut response = http::Response::new(empty_body()); 7187 7187 + let headers = response.headers_mut(); 7188 7188 + headers 7189 7189 + .insert( 7190 7190 + tonic::Status::GRPC_STATUS, 7191 7191 + (tonic::Code::Unimplemented as i32).into(), 7192 7192 + ); 7193 7193 + headers 7194 7194 + .insert( 7195 7195 + http::header::CONTENT_TYPE, 7196 7196 + tonic::metadata::GRPC_CONTENT_TYPE, 7197 7197 + ); 7198 7198 + Ok(response) 7199 7199 + }) 7200 7200 + } 6246 7201 } 6247 7202 } 6248 7203 } ··· 6400 7355 dead_code, 6401 7356 missing_docs, 6402 7357 clippy::wildcard_imports, 6403 6403 - clippy::let_unit_value 7358 7358 + clippy::let_unit_value, 6404 7359 )] 6405 6405 - use tonic::codegen::http::Uri; 6406 7360 use tonic::codegen::*; 7361 7361 + use tonic::codegen::http::Uri; 6407 7362 #[derive(Debug, Clone)] 6408 7363 pub struct SoundServiceClient<T> { 6409 7364 inner: tonic::client::Grpc<T>, ··· 6447 7402 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 6448 7403 >, 6449 7404 >, 6450 6450 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 6451 6451 - Into<StdError> + std::marker::Send + std::marker::Sync, 7405 7405 + <T as tonic::codegen::Service< 7406 7406 + http::Request<tonic::body::BoxBody>, 7407 7407 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6452 7408 { 6453 7409 SoundServiceClient::new(InterceptedService::new(inner, interceptor)) 6454 7410 } ··· 6486 7442 pub async fn adjust_volume( 6487 7443 &mut self, 6488 7444 request: impl tonic::IntoRequest<super::AdjustVolumeRequest>, 6489 6489 - ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status> 6490 6490 - { 6491 6491 - self.inner.ready().await.map_err(|e| { 6492 6492 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6493 6493 - })?; 7445 7445 + ) -> std::result::Result< 7446 7446 + tonic::Response<super::AdjustVolumeResponse>, 7447 7447 + tonic::Status, 7448 7448 + > { 7449 7449 + self.inner 7450 7450 + .ready() 7451 7451 + .await 7452 7452 + .map_err(|e| { 7453 7453 + tonic::Status::unknown( 7454 7454 + format!("Service was not ready: {}", e.into()), 7455 7455 + ) 7456 7456 + })?; 6494 7457 let codec = tonic::codec::ProstCodec::default(); 6495 6495 - let path = 6496 6496 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/AdjustVolume"); 7458 7458 + let path = http::uri::PathAndQuery::from_static( 7459 7459 + "/rockbox.v1alpha1.SoundService/AdjustVolume", 7460 7460 + ); 6497 7461 let mut req = request.into_request(); 6498 6498 - req.extensions_mut().insert(GrpcMethod::new( 6499 6499 - "rockbox.v1alpha1.SoundService", 6500 6500 - "AdjustVolume", 6501 6501 - )); 7462 7462 + req.extensions_mut() 7463 7463 + .insert( 7464 7464 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "AdjustVolume"), 7465 7465 + ); 6502 7466 self.inner.unary(req, path, codec).await 6503 7467 } 6504 7468 pub async fn sound_set( 6505 7469 &mut self, 6506 7470 request: impl tonic::IntoRequest<super::SoundSetRequest>, 6507 6507 - ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status> { 6508 6508 - self.inner.ready().await.map_err(|e| { 6509 6509 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6510 6510 - })?; 7471 7471 + ) -> std::result::Result< 7472 7472 + tonic::Response<super::SoundSetResponse>, 7473 7473 + tonic::Status, 7474 7474 + > { 7475 7475 + self.inner 7476 7476 + .ready() 7477 7477 + .await 7478 7478 + .map_err(|e| { 7479 7479 + tonic::Status::unknown( 7480 7480 + format!("Service was not ready: {}", e.into()), 7481 7481 + ) 7482 7482 + })?; 6511 7483 let codec = tonic::codec::ProstCodec::default(); 6512 6512 - let path = 6513 6513 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundSet"); 7484 7484 + let path = http::uri::PathAndQuery::from_static( 7485 7485 + "/rockbox.v1alpha1.SoundService/SoundSet", 7486 7486 + ); 6514 7487 let mut req = request.into_request(); 6515 7488 req.extensions_mut() 6516 7489 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundSet")); ··· 6519 7492 pub async fn sound_current( 6520 7493 &mut self, 6521 7494 request: impl tonic::IntoRequest<super::SoundCurrentRequest>, 6522 6522 - ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status> 6523 6523 - { 6524 6524 - self.inner.ready().await.map_err(|e| { 6525 6525 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6526 6526 - })?; 7495 7495 + ) -> std::result::Result< 7496 7496 + tonic::Response<super::SoundCurrentResponse>, 7497 7497 + tonic::Status, 7498 7498 + > { 7499 7499 + self.inner 7500 7500 + .ready() 7501 7501 + .await 7502 7502 + .map_err(|e| { 7503 7503 + tonic::Status::unknown( 7504 7504 + format!("Service was not ready: {}", e.into()), 7505 7505 + ) 7506 7506 + })?; 6527 7507 let codec = tonic::codec::ProstCodec::default(); 6528 6528 - let path = 6529 6529 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundCurrent"); 7508 7508 + let path = http::uri::PathAndQuery::from_static( 7509 7509 + "/rockbox.v1alpha1.SoundService/SoundCurrent", 7510 7510 + ); 6530 7511 let mut req = request.into_request(); 6531 6531 - req.extensions_mut().insert(GrpcMethod::new( 6532 6532 - "rockbox.v1alpha1.SoundService", 6533 6533 - "SoundCurrent", 6534 6534 - )); 7512 7512 + req.extensions_mut() 7513 7513 + .insert( 7514 7514 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundCurrent"), 7515 7515 + ); 6535 7516 self.inner.unary(req, path, codec).await 6536 7517 } 6537 7518 pub async fn sound_default( 6538 7519 &mut self, 6539 7520 request: impl tonic::IntoRequest<super::SoundDefaultRequest>, 6540 6540 - ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status> 6541 6541 - { 6542 6542 - self.inner.ready().await.map_err(|e| { 6543 6543 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6544 6544 - })?; 7521 7521 + ) -> std::result::Result< 7522 7522 + tonic::Response<super::SoundDefaultResponse>, 7523 7523 + tonic::Status, 7524 7524 + > { 7525 7525 + self.inner 7526 7526 + .ready() 7527 7527 + .await 7528 7528 + .map_err(|e| { 7529 7529 + tonic::Status::unknown( 7530 7530 + format!("Service was not ready: {}", e.into()), 7531 7531 + ) 7532 7532 + })?; 6545 7533 let codec = tonic::codec::ProstCodec::default(); 6546 6546 - let path = 6547 6547 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundDefault"); 7534 7534 + let path = http::uri::PathAndQuery::from_static( 7535 7535 + "/rockbox.v1alpha1.SoundService/SoundDefault", 7536 7536 + ); 6548 7537 let mut req = request.into_request(); 6549 6549 - req.extensions_mut().insert(GrpcMethod::new( 6550 6550 - "rockbox.v1alpha1.SoundService", 6551 6551 - "SoundDefault", 6552 6552 - )); 7538 7538 + req.extensions_mut() 7539 7539 + .insert( 7540 7540 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundDefault"), 7541 7541 + ); 6553 7542 self.inner.unary(req, path, codec).await 6554 7543 } 6555 7544 pub async fn sound_min( 6556 7545 &mut self, 6557 7546 request: impl tonic::IntoRequest<super::SoundMinRequest>, 6558 6558 - ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status> { 6559 6559 - self.inner.ready().await.map_err(|e| { 6560 6560 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6561 6561 - })?; 7547 7547 + ) -> std::result::Result< 7548 7548 + tonic::Response<super::SoundMinResponse>, 7549 7549 + tonic::Status, 7550 7550 + > { 7551 7551 + self.inner 7552 7552 + .ready() 7553 7553 + .await 7554 7554 + .map_err(|e| { 7555 7555 + tonic::Status::unknown( 7556 7556 + format!("Service was not ready: {}", e.into()), 7557 7557 + ) 7558 7558 + })?; 6562 7559 let codec = tonic::codec::ProstCodec::default(); 6563 6563 - let path = 6564 6564 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMin"); 7560 7560 + let path = http::uri::PathAndQuery::from_static( 7561 7561 + "/rockbox.v1alpha1.SoundService/SoundMin", 7562 7562 + ); 6565 7563 let mut req = request.into_request(); 6566 7564 req.extensions_mut() 6567 7565 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMin")); ··· 6570 7568 pub async fn sound_max( 6571 7569 &mut self, 6572 7570 request: impl tonic::IntoRequest<super::SoundMaxRequest>, 6573 6573 - ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status> { 6574 6574 - self.inner.ready().await.map_err(|e| { 6575 6575 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6576 6576 - })?; 7571 7571 + ) -> std::result::Result< 7572 7572 + tonic::Response<super::SoundMaxResponse>, 7573 7573 + tonic::Status, 7574 7574 + > { 7575 7575 + self.inner 7576 7576 + .ready() 7577 7577 + .await 7578 7578 + .map_err(|e| { 7579 7579 + tonic::Status::unknown( 7580 7580 + format!("Service was not ready: {}", e.into()), 7581 7581 + ) 7582 7582 + })?; 6577 7583 let codec = tonic::codec::ProstCodec::default(); 6578 6578 - let path = 6579 6579 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMax"); 7584 7584 + let path = http::uri::PathAndQuery::from_static( 7585 7585 + "/rockbox.v1alpha1.SoundService/SoundMax", 7586 7586 + ); 6580 7587 let mut req = request.into_request(); 6581 7588 req.extensions_mut() 6582 7589 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMax")); ··· 6585 7592 pub async fn sound_unit( 6586 7593 &mut self, 6587 7594 request: impl tonic::IntoRequest<super::SoundUnitRequest>, 6588 6588 - ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status> { 6589 6589 - self.inner.ready().await.map_err(|e| { 6590 6590 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6591 6591 - })?; 7595 7595 + ) -> std::result::Result< 7596 7596 + tonic::Response<super::SoundUnitResponse>, 7597 7597 + tonic::Status, 7598 7598 + > { 7599 7599 + self.inner 7600 7600 + .ready() 7601 7601 + .await 7602 7602 + .map_err(|e| { 7603 7603 + tonic::Status::unknown( 7604 7604 + format!("Service was not ready: {}", e.into()), 7605 7605 + ) 7606 7606 + })?; 6592 7607 let codec = tonic::codec::ProstCodec::default(); 6593 6593 - let path = 6594 6594 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundUnit"); 7608 7608 + let path = http::uri::PathAndQuery::from_static( 7609 7609 + "/rockbox.v1alpha1.SoundService/SoundUnit", 7610 7610 + ); 6595 7611 let mut req = request.into_request(); 6596 6596 - req.extensions_mut().insert(GrpcMethod::new( 6597 6597 - "rockbox.v1alpha1.SoundService", 6598 6598 - "SoundUnit", 6599 6599 - )); 7612 7612 + req.extensions_mut() 7613 7613 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundUnit")); 6600 7614 self.inner.unary(req, path, codec).await 6601 7615 } 6602 7616 pub async fn sound_val2_phys( 6603 7617 &mut self, 6604 7618 request: impl tonic::IntoRequest<super::SoundVal2PhysRequest>, 6605 6605 - ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status> 6606 6606 - { 6607 6607 - self.inner.ready().await.map_err(|e| { 6608 6608 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6609 6609 - })?; 7619 7619 + ) -> std::result::Result< 7620 7620 + tonic::Response<super::SoundVal2PhysResponse>, 7621 7621 + tonic::Status, 7622 7622 + > { 7623 7623 + self.inner 7624 7624 + .ready() 7625 7625 + .await 7626 7626 + .map_err(|e| { 7627 7627 + tonic::Status::unknown( 7628 7628 + format!("Service was not ready: {}", e.into()), 7629 7629 + ) 7630 7630 + })?; 6610 7631 let codec = tonic::codec::ProstCodec::default(); 6611 7632 let path = http::uri::PathAndQuery::from_static( 6612 7633 "/rockbox.v1alpha1.SoundService/SoundVal2Phys", 6613 7634 ); 6614 7635 let mut req = request.into_request(); 6615 6615 - req.extensions_mut().insert(GrpcMethod::new( 6616 6616 - "rockbox.v1alpha1.SoundService", 6617 6617 - "SoundVal2Phys", 6618 6618 - )); 7636 7636 + req.extensions_mut() 7637 7637 + .insert( 7638 7638 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundVal2Phys"), 7639 7639 + ); 6619 7640 self.inner.unary(req, path, codec).await 6620 7641 } 6621 7642 pub async fn get_pitch( 6622 7643 &mut self, 6623 7644 request: impl tonic::IntoRequest<super::GetPitchRequest>, 6624 6624 - ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status> { 6625 6625 - self.inner.ready().await.map_err(|e| { 6626 6626 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6627 6627 - })?; 7645 7645 + ) -> std::result::Result< 7646 7646 + tonic::Response<super::GetPitchResponse>, 7647 7647 + tonic::Status, 7648 7648 + > { 7649 7649 + self.inner 7650 7650 + .ready() 7651 7651 + .await 7652 7652 + .map_err(|e| { 7653 7653 + tonic::Status::unknown( 7654 7654 + format!("Service was not ready: {}", e.into()), 7655 7655 + ) 7656 7656 + })?; 6628 7657 let codec = tonic::codec::ProstCodec::default(); 6629 6629 - let path = 6630 6630 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/GetPitch"); 7658 7658 + let path = http::uri::PathAndQuery::from_static( 7659 7659 + "/rockbox.v1alpha1.SoundService/GetPitch", 7660 7660 + ); 6631 7661 let mut req = request.into_request(); 6632 7662 req.extensions_mut() 6633 7663 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "GetPitch")); ··· 6636 7666 pub async fn set_pitch( 6637 7667 &mut self, 6638 7668 request: impl tonic::IntoRequest<super::SetPitchRequest>, 6639 6639 - ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status> { 6640 6640 - self.inner.ready().await.map_err(|e| { 6641 6641 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6642 6642 - })?; 7669 7669 + ) -> std::result::Result< 7670 7670 + tonic::Response<super::SetPitchResponse>, 7671 7671 + tonic::Status, 7672 7672 + > { 7673 7673 + self.inner 7674 7674 + .ready() 7675 7675 + .await 7676 7676 + .map_err(|e| { 7677 7677 + tonic::Status::unknown( 7678 7678 + format!("Service was not ready: {}", e.into()), 7679 7679 + ) 7680 7680 + })?; 6643 7681 let codec = tonic::codec::ProstCodec::default(); 6644 6644 - let path = 6645 6645 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SetPitch"); 7682 7682 + let path = http::uri::PathAndQuery::from_static( 7683 7683 + "/rockbox.v1alpha1.SoundService/SetPitch", 7684 7684 + ); 6646 7685 let mut req = request.into_request(); 6647 7686 req.extensions_mut() 6648 7687 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SetPitch")); ··· 6651 7690 pub async fn beep_play( 6652 7691 &mut self, 6653 7692 request: impl tonic::IntoRequest<super::BeepPlayRequest>, 6654 6654 - ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status> { 6655 6655 - self.inner.ready().await.map_err(|e| { 6656 6656 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6657 6657 - })?; 7693 7693 + ) -> std::result::Result< 7694 7694 + tonic::Response<super::BeepPlayResponse>, 7695 7695 + tonic::Status, 7696 7696 + > { 7697 7697 + self.inner 7698 7698 + .ready() 7699 7699 + .await 7700 7700 + .map_err(|e| { 7701 7701 + tonic::Status::unknown( 7702 7702 + format!("Service was not ready: {}", e.into()), 7703 7703 + ) 7704 7704 + })?; 6658 7705 let codec = tonic::codec::ProstCodec::default(); 6659 6659 - let path = 6660 6660 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/BeepPlay"); 7706 7706 + let path = http::uri::PathAndQuery::from_static( 7707 7707 + "/rockbox.v1alpha1.SoundService/BeepPlay", 7708 7708 + ); 6661 7709 let mut req = request.into_request(); 6662 7710 req.extensions_mut() 6663 7711 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "BeepPlay")); ··· 6666 7714 pub async fn pcmbuf_fade( 6667 7715 &mut self, 6668 7716 request: impl tonic::IntoRequest<super::PcmbufFadeRequest>, 6669 6669 - ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status> 6670 6670 - { 6671 6671 - self.inner.ready().await.map_err(|e| { 6672 6672 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6673 6673 - })?; 7717 7717 + ) -> std::result::Result< 7718 7718 + tonic::Response<super::PcmbufFadeResponse>, 7719 7719 + tonic::Status, 7720 7720 + > { 7721 7721 + self.inner 7722 7722 + .ready() 7723 7723 + .await 7724 7724 + .map_err(|e| { 7725 7725 + tonic::Status::unknown( 7726 7726 + format!("Service was not ready: {}", e.into()), 7727 7727 + ) 7728 7728 + })?; 6674 7729 let codec = tonic::codec::ProstCodec::default(); 6675 6675 - let path = 6676 6676 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/PcmbufFade"); 7730 7730 + let path = http::uri::PathAndQuery::from_static( 7731 7731 + "/rockbox.v1alpha1.SoundService/PcmbufFade", 7732 7732 + ); 6677 7733 let mut req = request.into_request(); 6678 6678 - req.extensions_mut().insert(GrpcMethod::new( 6679 6679 - "rockbox.v1alpha1.SoundService", 6680 6680 - "PcmbufFade", 6681 6681 - )); 7734 7734 + req.extensions_mut() 7735 7735 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "PcmbufFade")); 6682 7736 self.inner.unary(req, path, codec).await 6683 7737 } 6684 7738 pub async fn pcmbuf_set_low_latency( 6685 7739 &mut self, 6686 7740 request: impl tonic::IntoRequest<super::PcmbufSetLowLatencyRequest>, 6687 6687 - ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status> 6688 6688 - { 6689 6689 - self.inner.ready().await.map_err(|e| { 6690 6690 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6691 6691 - })?; 7741 7741 + ) -> std::result::Result< 7742 7742 + tonic::Response<super::PcmbufSetLowLatencyResponse>, 7743 7743 + tonic::Status, 7744 7744 + > { 7745 7745 + self.inner 7746 7746 + .ready() 7747 7747 + .await 7748 7748 + .map_err(|e| { 7749 7749 + tonic::Status::unknown( 7750 7750 + format!("Service was not ready: {}", e.into()), 7751 7751 + ) 7752 7752 + })?; 6692 7753 let codec = tonic::codec::ProstCodec::default(); 6693 7754 let path = http::uri::PathAndQuery::from_static( 6694 7755 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency", 6695 7756 ); 6696 7757 let mut req = request.into_request(); 6697 6697 - req.extensions_mut().insert(GrpcMethod::new( 6698 6698 - "rockbox.v1alpha1.SoundService", 6699 6699 - "PcmbufSetLowLatency", 6700 6700 - )); 7758 7758 + req.extensions_mut() 7759 7759 + .insert( 7760 7760 + GrpcMethod::new( 7761 7761 + "rockbox.v1alpha1.SoundService", 7762 7762 + "PcmbufSetLowLatency", 7763 7763 + ), 7764 7764 + ); 6701 7765 self.inner.unary(req, path, codec).await 6702 7766 } 6703 7767 pub async fn system_sound_play( 6704 7768 &mut self, 6705 7769 request: impl tonic::IntoRequest<super::SystemSoundPlayRequest>, 6706 6706 - ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status> 6707 6707 - { 6708 6708 - self.inner.ready().await.map_err(|e| { 6709 6709 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6710 6710 - })?; 7770 7770 + ) -> std::result::Result< 7771 7771 + tonic::Response<super::SystemSoundPlayResponse>, 7772 7772 + tonic::Status, 7773 7773 + > { 7774 7774 + self.inner 7775 7775 + .ready() 7776 7776 + .await 7777 7777 + .map_err(|e| { 7778 7778 + tonic::Status::unknown( 7779 7779 + format!("Service was not ready: {}", e.into()), 7780 7780 + ) 7781 7781 + })?; 6711 7782 let codec = tonic::codec::ProstCodec::default(); 6712 7783 let path = http::uri::PathAndQuery::from_static( 6713 7784 "/rockbox.v1alpha1.SoundService/SystemSoundPlay", 6714 7785 ); 6715 7786 let mut req = request.into_request(); 6716 6716 - req.extensions_mut().insert(GrpcMethod::new( 6717 6717 - "rockbox.v1alpha1.SoundService", 6718 6718 - "SystemSoundPlay", 6719 6719 - )); 7787 7787 + req.extensions_mut() 7788 7788 + .insert( 7789 7789 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SystemSoundPlay"), 7790 7790 + ); 6720 7791 self.inner.unary(req, path, codec).await 6721 7792 } 6722 7793 pub async fn keyclick_click( 6723 7794 &mut self, 6724 7795 request: impl tonic::IntoRequest<super::KeyclickClickRequest>, 6725 6725 - ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status> 6726 6726 - { 6727 6727 - self.inner.ready().await.map_err(|e| { 6728 6728 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6729 6729 - })?; 7796 7796 + ) -> std::result::Result< 7797 7797 + tonic::Response<super::KeyclickClickResponse>, 7798 7798 + tonic::Status, 7799 7799 + > { 7800 7800 + self.inner 7801 7801 + .ready() 7802 7802 + .await 7803 7803 + .map_err(|e| { 7804 7804 + tonic::Status::unknown( 7805 7805 + format!("Service was not ready: {}", e.into()), 7806 7806 + ) 7807 7807 + })?; 6730 7808 let codec = tonic::codec::ProstCodec::default(); 6731 7809 let path = http::uri::PathAndQuery::from_static( 6732 7810 "/rockbox.v1alpha1.SoundService/KeyclickClick", 6733 7811 ); 6734 7812 let mut req = request.into_request(); 6735 6735 - req.extensions_mut().insert(GrpcMethod::new( 6736 6736 - "rockbox.v1alpha1.SoundService", 6737 6737 - "KeyclickClick", 6738 6738 - )); 7813 7813 + req.extensions_mut() 7814 7814 + .insert( 7815 7815 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "KeyclickClick"), 7816 7816 + ); 6739 7817 self.inner.unary(req, path, codec).await 6740 7818 } 6741 7819 } ··· 6747 7825 dead_code, 6748 7826 missing_docs, 6749 7827 clippy::wildcard_imports, 6750 6750 - clippy::let_unit_value 7828 7828 + clippy::let_unit_value, 6751 7829 )] 6752 7830 use tonic::codegen::*; 6753 7831 /// Generated trait containing gRPC methods that should be implemented for use with SoundServiceServer. ··· 6756 7834 async fn adjust_volume( 6757 7835 &self, 6758 7836 request: tonic::Request<super::AdjustVolumeRequest>, 6759 6759 - ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status>; 7837 7837 + ) -> std::result::Result< 7838 7838 + tonic::Response<super::AdjustVolumeResponse>, 7839 7839 + tonic::Status, 7840 7840 + >; 6760 7841 async fn sound_set( 6761 7842 &self, 6762 7843 request: tonic::Request<super::SoundSetRequest>, 6763 6763 - ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status>; 7844 7844 + ) -> std::result::Result< 7845 7845 + tonic::Response<super::SoundSetResponse>, 7846 7846 + tonic::Status, 7847 7847 + >; 6764 7848 async fn sound_current( 6765 7849 &self, 6766 7850 request: tonic::Request<super::SoundCurrentRequest>, 6767 6767 - ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status>; 7851 7851 + ) -> std::result::Result< 7852 7852 + tonic::Response<super::SoundCurrentResponse>, 7853 7853 + tonic::Status, 7854 7854 + >; 6768 7855 async fn sound_default( 6769 7856 &self, 6770 7857 request: tonic::Request<super::SoundDefaultRequest>, 6771 6771 - ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status>; 7858 7858 + ) -> std::result::Result< 7859 7859 + tonic::Response<super::SoundDefaultResponse>, 7860 7860 + tonic::Status, 7861 7861 + >; 6772 7862 async fn sound_min( 6773 7863 &self, 6774 7864 request: tonic::Request<super::SoundMinRequest>, 6775 6775 - ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status>; 7865 7865 + ) -> std::result::Result< 7866 7866 + tonic::Response<super::SoundMinResponse>, 7867 7867 + tonic::Status, 7868 7868 + >; 6776 7869 async fn sound_max( 6777 7870 &self, 6778 7871 request: tonic::Request<super::SoundMaxRequest>, 6779 6779 - ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status>; 7872 7872 + ) -> std::result::Result< 7873 7873 + tonic::Response<super::SoundMaxResponse>, 7874 7874 + tonic::Status, 7875 7875 + >; 6780 7876 async fn sound_unit( 6781 7877 &self, 6782 7878 request: tonic::Request<super::SoundUnitRequest>, 6783 6783 - ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status>; 7879 7879 + ) -> std::result::Result< 7880 7880 + tonic::Response<super::SoundUnitResponse>, 7881 7881 + tonic::Status, 7882 7882 + >; 6784 7883 async fn sound_val2_phys( 6785 7884 &self, 6786 7885 request: tonic::Request<super::SoundVal2PhysRequest>, 6787 6787 - ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status>; 7886 7886 + ) -> std::result::Result< 7887 7887 + tonic::Response<super::SoundVal2PhysResponse>, 7888 7888 + tonic::Status, 7889 7889 + >; 6788 7890 async fn get_pitch( 6789 7891 &self, 6790 7892 request: tonic::Request<super::GetPitchRequest>, 6791 6791 - ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status>; 7893 7893 + ) -> std::result::Result< 7894 7894 + tonic::Response<super::GetPitchResponse>, 7895 7895 + tonic::Status, 7896 7896 + >; 6792 7897 async fn set_pitch( 6793 7898 &self, 6794 7899 request: tonic::Request<super::SetPitchRequest>, 6795 6795 - ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status>; 7900 7900 + ) -> std::result::Result< 7901 7901 + tonic::Response<super::SetPitchResponse>, 7902 7902 + tonic::Status, 7903 7903 + >; 6796 7904 async fn beep_play( 6797 7905 &self, 6798 7906 request: tonic::Request<super::BeepPlayRequest>, 6799 6799 - ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status>; 7907 7907 + ) -> std::result::Result< 7908 7908 + tonic::Response<super::BeepPlayResponse>, 7909 7909 + tonic::Status, 7910 7910 + >; 6800 7911 async fn pcmbuf_fade( 6801 7912 &self, 6802 7913 request: tonic::Request<super::PcmbufFadeRequest>, 6803 6803 - ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status>; 7914 7914 + ) -> std::result::Result< 7915 7915 + tonic::Response<super::PcmbufFadeResponse>, 7916 7916 + tonic::Status, 7917 7917 + >; 6804 7918 async fn pcmbuf_set_low_latency( 6805 7919 &self, 6806 7920 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 6807 6807 - ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status>; 7921 7921 + ) -> std::result::Result< 7922 7922 + tonic::Response<super::PcmbufSetLowLatencyResponse>, 7923 7923 + tonic::Status, 7924 7924 + >; 6808 7925 async fn system_sound_play( 6809 7926 &self, 6810 7927 request: tonic::Request<super::SystemSoundPlayRequest>, 6811 6811 - ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status>; 7928 7928 + ) -> std::result::Result< 7929 7929 + tonic::Response<super::SystemSoundPlayResponse>, 7930 7930 + tonic::Status, 7931 7931 + >; 6812 7932 async fn keyclick_click( 6813 7933 &self, 6814 7934 request: tonic::Request<super::KeyclickClickRequest>, 6815 6815 - ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>; 7935 7935 + ) -> std::result::Result< 7936 7936 + tonic::Response<super::KeyclickClickResponse>, 7937 7937 + tonic::Status, 7938 7938 + >; 6816 7939 } 6817 7940 #[derive(Debug)] 6818 7941 pub struct SoundServiceServer<T> { ··· 6835 7958 max_encoding_message_size: None, 6836 7959 } 6837 7960 } 6838 6838 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 7961 7961 + pub fn with_interceptor<F>( 7962 7962 + inner: T, 7963 7963 + interceptor: F, 7964 7964 + ) -> InterceptedService<Self, F> 6839 7965 where 6840 7966 F: tonic::service::Interceptor, 6841 7967 { ··· 6890 8016 "/rockbox.v1alpha1.SoundService/AdjustVolume" => { 6891 8017 #[allow(non_camel_case_types)] 6892 8018 struct AdjustVolumeSvc<T: SoundService>(pub Arc<T>); 6893 6893 - impl<T: SoundService> tonic::server::UnaryService<super::AdjustVolumeRequest> 6894 6894 - for AdjustVolumeSvc<T> 6895 6895 - { 8019 8019 + impl< 8020 8020 + T: SoundService, 8021 8021 + > tonic::server::UnaryService<super::AdjustVolumeRequest> 8022 8022 + for AdjustVolumeSvc<T> { 6896 8023 type Response = super::AdjustVolumeResponse; 6897 6897 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8024 8024 + type Future = BoxFuture< 8025 8025 + tonic::Response<Self::Response>, 8026 8026 + tonic::Status, 8027 8027 + >; 6898 8028 fn call( 6899 8029 &mut self, 6900 8030 request: tonic::Request<super::AdjustVolumeRequest>, ··· 6931 8061 "/rockbox.v1alpha1.SoundService/SoundSet" => { 6932 8062 #[allow(non_camel_case_types)] 6933 8063 struct SoundSetSvc<T: SoundService>(pub Arc<T>); 6934 6934 - impl<T: SoundService> tonic::server::UnaryService<super::SoundSetRequest> for SoundSetSvc<T> { 8064 8064 + impl< 8065 8065 + T: SoundService, 8066 8066 + > tonic::server::UnaryService<super::SoundSetRequest> 8067 8067 + for SoundSetSvc<T> { 6935 8068 type Response = super::SoundSetResponse; 6936 6936 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8069 8069 + type Future = BoxFuture< 8070 8070 + tonic::Response<Self::Response>, 8071 8071 + tonic::Status, 8072 8072 + >; 6937 8073 fn call( 6938 8074 &mut self, 6939 8075 request: tonic::Request<super::SoundSetRequest>, ··· 6970 8106 "/rockbox.v1alpha1.SoundService/SoundCurrent" => { 6971 8107 #[allow(non_camel_case_types)] 6972 8108 struct SoundCurrentSvc<T: SoundService>(pub Arc<T>); 6973 6973 - impl<T: SoundService> tonic::server::UnaryService<super::SoundCurrentRequest> 6974 6974 - for SoundCurrentSvc<T> 6975 6975 - { 8109 8109 + impl< 8110 8110 + T: SoundService, 8111 8111 + > tonic::server::UnaryService<super::SoundCurrentRequest> 8112 8112 + for SoundCurrentSvc<T> { 6976 8113 type Response = super::SoundCurrentResponse; 6977 6977 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8114 8114 + type Future = BoxFuture< 8115 8115 + tonic::Response<Self::Response>, 8116 8116 + tonic::Status, 8117 8117 + >; 6978 8118 fn call( 6979 8119 &mut self, 6980 8120 request: tonic::Request<super::SoundCurrentRequest>, ··· 7011 8151 "/rockbox.v1alpha1.SoundService/SoundDefault" => { 7012 8152 #[allow(non_camel_case_types)] 7013 8153 struct SoundDefaultSvc<T: SoundService>(pub Arc<T>); 7014 7014 - impl<T: SoundService> tonic::server::UnaryService<super::SoundDefaultRequest> 7015 7015 - for SoundDefaultSvc<T> 7016 7016 - { 8154 8154 + impl< 8155 8155 + T: SoundService, 8156 8156 + > tonic::server::UnaryService<super::SoundDefaultRequest> 8157 8157 + for SoundDefaultSvc<T> { 7017 8158 type Response = super::SoundDefaultResponse; 7018 7018 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8159 8159 + type Future = BoxFuture< 8160 8160 + tonic::Response<Self::Response>, 8161 8161 + tonic::Status, 8162 8162 + >; 7019 8163 fn call( 7020 8164 &mut self, 7021 8165 request: tonic::Request<super::SoundDefaultRequest>, ··· 7052 8196 "/rockbox.v1alpha1.SoundService/SoundMin" => { 7053 8197 #[allow(non_camel_case_types)] 7054 8198 struct SoundMinSvc<T: SoundService>(pub Arc<T>); 7055 7055 - impl<T: SoundService> tonic::server::UnaryService<super::SoundMinRequest> for SoundMinSvc<T> { 8199 8199 + impl< 8200 8200 + T: SoundService, 8201 8201 + > tonic::server::UnaryService<super::SoundMinRequest> 8202 8202 + for SoundMinSvc<T> { 7056 8203 type Response = super::SoundMinResponse; 7057 7057 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8204 8204 + type Future = BoxFuture< 8205 8205 + tonic::Response<Self::Response>, 8206 8206 + tonic::Status, 8207 8207 + >; 7058 8208 fn call( 7059 8209 &mut self, 7060 8210 request: tonic::Request<super::SoundMinRequest>, ··· 7091 8241 "/rockbox.v1alpha1.SoundService/SoundMax" => { 7092 8242 #[allow(non_camel_case_types)] 7093 8243 struct SoundMaxSvc<T: SoundService>(pub Arc<T>); 7094 7094 - impl<T: SoundService> tonic::server::UnaryService<super::SoundMaxRequest> for SoundMaxSvc<T> { 8244 8244 + impl< 8245 8245 + T: SoundService, 8246 8246 + > tonic::server::UnaryService<super::SoundMaxRequest> 8247 8247 + for SoundMaxSvc<T> { 7095 8248 type Response = super::SoundMaxResponse; 7096 7096 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8249 8249 + type Future = BoxFuture< 8250 8250 + tonic::Response<Self::Response>, 8251 8251 + tonic::Status, 8252 8252 + >; 7097 8253 fn call( 7098 8254 &mut self, 7099 8255 request: tonic::Request<super::SoundMaxRequest>, ··· 7130 8286 "/rockbox.v1alpha1.SoundService/SoundUnit" => { 7131 8287 #[allow(non_camel_case_types)] 7132 8288 struct SoundUnitSvc<T: SoundService>(pub Arc<T>); 7133 7133 - impl<T: SoundService> tonic::server::UnaryService<super::SoundUnitRequest> for SoundUnitSvc<T> { 8289 8289 + impl< 8290 8290 + T: SoundService, 8291 8291 + > tonic::server::UnaryService<super::SoundUnitRequest> 8292 8292 + for SoundUnitSvc<T> { 7134 8293 type Response = super::SoundUnitResponse; 7135 7135 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8294 8294 + type Future = BoxFuture< 8295 8295 + tonic::Response<Self::Response>, 8296 8296 + tonic::Status, 8297 8297 + >; 7136 8298 fn call( 7137 8299 &mut self, 7138 8300 request: tonic::Request<super::SoundUnitRequest>, ··· 7169 8331 "/rockbox.v1alpha1.SoundService/SoundVal2Phys" => { 7170 8332 #[allow(non_camel_case_types)] 7171 8333 struct SoundVal2PhysSvc<T: SoundService>(pub Arc<T>); 7172 7172 - impl<T: SoundService> tonic::server::UnaryService<super::SoundVal2PhysRequest> 7173 7173 - for SoundVal2PhysSvc<T> 7174 7174 - { 8334 8334 + impl< 8335 8335 + T: SoundService, 8336 8336 + > tonic::server::UnaryService<super::SoundVal2PhysRequest> 8337 8337 + for SoundVal2PhysSvc<T> { 7175 8338 type Response = super::SoundVal2PhysResponse; 7176 7176 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8339 8339 + type Future = BoxFuture< 8340 8340 + tonic::Response<Self::Response>, 8341 8341 + tonic::Status, 8342 8342 + >; 7177 8343 fn call( 7178 8344 &mut self, 7179 8345 request: tonic::Request<super::SoundVal2PhysRequest>, ··· 7210 8376 "/rockbox.v1alpha1.SoundService/GetPitch" => { 7211 8377 #[allow(non_camel_case_types)] 7212 8378 struct GetPitchSvc<T: SoundService>(pub Arc<T>); 7213 7213 - impl<T: SoundService> tonic::server::UnaryService<super::GetPitchRequest> for GetPitchSvc<T> { 8379 8379 + impl< 8380 8380 + T: SoundService, 8381 8381 + > tonic::server::UnaryService<super::GetPitchRequest> 8382 8382 + for GetPitchSvc<T> { 7214 8383 type Response = super::GetPitchResponse; 7215 7215 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8384 8384 + type Future = BoxFuture< 8385 8385 + tonic::Response<Self::Response>, 8386 8386 + tonic::Status, 8387 8387 + >; 7216 8388 fn call( 7217 8389 &mut self, 7218 8390 request: tonic::Request<super::GetPitchRequest>, ··· 7249 8421 "/rockbox.v1alpha1.SoundService/SetPitch" => { 7250 8422 #[allow(non_camel_case_types)] 7251 8423 struct SetPitchSvc<T: SoundService>(pub Arc<T>); 7252 7252 - impl<T: SoundService> tonic::server::UnaryService<super::SetPitchRequest> for SetPitchSvc<T> { 8424 8424 + impl< 8425 8425 + T: SoundService, 8426 8426 + > tonic::server::UnaryService<super::SetPitchRequest> 8427 8427 + for SetPitchSvc<T> { 7253 8428 type Response = super::SetPitchResponse; 7254 7254 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8429 8429 + type Future = BoxFuture< 8430 8430 + tonic::Response<Self::Response>, 8431 8431 + tonic::Status, 8432 8432 + >; 7255 8433 fn call( 7256 8434 &mut self, 7257 8435 request: tonic::Request<super::SetPitchRequest>, ··· 7288 8466 "/rockbox.v1alpha1.SoundService/BeepPlay" => { 7289 8467 #[allow(non_camel_case_types)] 7290 8468 struct BeepPlaySvc<T: SoundService>(pub Arc<T>); 7291 7291 - impl<T: SoundService> tonic::server::UnaryService<super::BeepPlayRequest> for BeepPlaySvc<T> { 8469 8469 + impl< 8470 8470 + T: SoundService, 8471 8471 + > tonic::server::UnaryService<super::BeepPlayRequest> 8472 8472 + for BeepPlaySvc<T> { 7292 8473 type Response = super::BeepPlayResponse; 7293 7293 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8474 8474 + type Future = BoxFuture< 8475 8475 + tonic::Response<Self::Response>, 8476 8476 + tonic::Status, 8477 8477 + >; 7294 8478 fn call( 7295 8479 &mut self, 7296 8480 request: tonic::Request<super::BeepPlayRequest>, ··· 7327 8511 "/rockbox.v1alpha1.SoundService/PcmbufFade" => { 7328 8512 #[allow(non_camel_case_types)] 7329 8513 struct PcmbufFadeSvc<T: SoundService>(pub Arc<T>); 7330 7330 - impl<T: SoundService> tonic::server::UnaryService<super::PcmbufFadeRequest> for PcmbufFadeSvc<T> { 8514 8514 + impl< 8515 8515 + T: SoundService, 8516 8516 + > tonic::server::UnaryService<super::PcmbufFadeRequest> 8517 8517 + for PcmbufFadeSvc<T> { 7331 8518 type Response = super::PcmbufFadeResponse; 7332 7332 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8519 8519 + type Future = BoxFuture< 8520 8520 + tonic::Response<Self::Response>, 8521 8521 + tonic::Status, 8522 8522 + >; 7333 8523 fn call( 7334 8524 &mut self, 7335 8525 request: tonic::Request<super::PcmbufFadeRequest>, ··· 7366 8556 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency" => { 7367 8557 #[allow(non_camel_case_types)] 7368 8558 struct PcmbufSetLowLatencySvc<T: SoundService>(pub Arc<T>); 7369 7369 - impl<T: SoundService> 7370 7370 - tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 7371 7371 - for PcmbufSetLowLatencySvc<T> 7372 7372 - { 8559 8559 + impl< 8560 8560 + T: SoundService, 8561 8561 + > tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 8562 8562 + for PcmbufSetLowLatencySvc<T> { 7373 8563 type Response = super::PcmbufSetLowLatencyResponse; 7374 7374 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8564 8564 + type Future = BoxFuture< 8565 8565 + tonic::Response<Self::Response>, 8566 8566 + tonic::Status, 8567 8567 + >; 7375 8568 fn call( 7376 8569 &mut self, 7377 8570 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 7378 8571 ) -> Self::Future { 7379 8572 let inner = Arc::clone(&self.0); 7380 8573 let fut = async move { 7381 7381 - <T as SoundService>::pcmbuf_set_low_latency(&inner, request).await 8574 8574 + <T as SoundService>::pcmbuf_set_low_latency(&inner, request) 8575 8575 + .await 7382 8576 }; 7383 8577 Box::pin(fut) 7384 8578 } ··· 7408 8602 "/rockbox.v1alpha1.SoundService/SystemSoundPlay" => { 7409 8603 #[allow(non_camel_case_types)] 7410 8604 struct SystemSoundPlaySvc<T: SoundService>(pub Arc<T>); 7411 7411 - impl<T: SoundService> tonic::server::UnaryService<super::SystemSoundPlayRequest> 7412 7412 - for SystemSoundPlaySvc<T> 7413 7413 - { 8605 8605 + impl< 8606 8606 + T: SoundService, 8607 8607 + > tonic::server::UnaryService<super::SystemSoundPlayRequest> 8608 8608 + for SystemSoundPlaySvc<T> { 7414 8609 type Response = super::SystemSoundPlayResponse; 7415 7415 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8610 8610 + type Future = BoxFuture< 8611 8611 + tonic::Response<Self::Response>, 8612 8612 + tonic::Status, 8613 8613 + >; 7416 8614 fn call( 7417 8615 &mut self, 7418 8616 request: tonic::Request<super::SystemSoundPlayRequest>, 7419 8617 ) -> Self::Future { 7420 8618 let inner = Arc::clone(&self.0); 7421 8619 let fut = async move { 7422 7422 - <T as SoundService>::system_sound_play(&inner, request).await 8620 8620 + <T as SoundService>::system_sound_play(&inner, request) 8621 8621 + .await 7423 8622 }; 7424 8623 Box::pin(fut) 7425 8624 } ··· 7449 8648 "/rockbox.v1alpha1.SoundService/KeyclickClick" => { 7450 8649 #[allow(non_camel_case_types)] 7451 8650 struct KeyclickClickSvc<T: SoundService>(pub Arc<T>); 7452 7452 - impl<T: SoundService> tonic::server::UnaryService<super::KeyclickClickRequest> 7453 7453 - for KeyclickClickSvc<T> 7454 7454 - { 8651 8651 + impl< 8652 8652 + T: SoundService, 8653 8653 + > tonic::server::UnaryService<super::KeyclickClickRequest> 8654 8654 + for KeyclickClickSvc<T> { 7455 8655 type Response = super::KeyclickClickResponse; 7456 7456 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8656 8656 + type Future = BoxFuture< 8657 8657 + tonic::Response<Self::Response>, 8658 8658 + tonic::Status, 8659 8659 + >; 7457 8660 fn call( 7458 8661 &mut self, 7459 8662 request: tonic::Request<super::KeyclickClickRequest>, ··· 7487 8690 }; 7488 8691 Box::pin(fut) 7489 8692 } 7490 7490 - _ => Box::pin(async move { 7491 7491 - let mut response = http::Response::new(empty_body()); 7492 7492 - let headers = response.headers_mut(); 7493 7493 - headers.insert( 7494 7494 - tonic::Status::GRPC_STATUS, 7495 7495 - (tonic::Code::Unimplemented as i32).into(), 7496 7496 - ); 7497 7497 - headers.insert( 7498 7498 - http::header::CONTENT_TYPE, 7499 7499 - tonic::metadata::GRPC_CONTENT_TYPE, 7500 7500 - ); 7501 7501 - Ok(response) 7502 7502 - }), 8693 8693 + _ => { 8694 8694 + Box::pin(async move { 8695 8695 + let mut response = http::Response::new(empty_body()); 8696 8696 + let headers = response.headers_mut(); 8697 8697 + headers 8698 8698 + .insert( 8699 8699 + tonic::Status::GRPC_STATUS, 8700 8700 + (tonic::Code::Unimplemented as i32).into(), 8701 8701 + ); 8702 8702 + headers 8703 8703 + .insert( 8704 8704 + http::header::CONTENT_TYPE, 8705 8705 + tonic::metadata::GRPC_CONTENT_TYPE, 8706 8706 + ); 8707 8707 + Ok(response) 8708 8708 + }) 8709 8709 + } 7503 8710 } 7504 8711 } 7505 8712 } ··· 7560 8767 dead_code, 7561 8768 missing_docs, 7562 8769 clippy::wildcard_imports, 7563 7563 - clippy::let_unit_value 8770 8770 + clippy::let_unit_value, 7564 8771 )] 7565 7565 - use tonic::codegen::http::Uri; 7566 8772 use tonic::codegen::*; 8773 8773 + use tonic::codegen::http::Uri; 7567 8774 #[derive(Debug, Clone)] 7568 8775 pub struct SystemServiceClient<T> { 7569 8776 inner: tonic::client::Grpc<T>, ··· 7607 8814 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 7608 8815 >, 7609 8816 >, 7610 7610 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 7611 7611 - Into<StdError> + std::marker::Send + std::marker::Sync, 8817 8817 + <T as tonic::codegen::Service< 8818 8818 + http::Request<tonic::body::BoxBody>, 8819 8819 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 7612 8820 { 7613 8821 SystemServiceClient::new(InterceptedService::new(inner, interceptor)) 7614 8822 } ··· 7646 8854 pub async fn get_rockbox_version( 7647 8855 &mut self, 7648 8856 request: impl tonic::IntoRequest<super::GetRockboxVersionRequest>, 7649 7649 - ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status> 7650 7650 - { 7651 7651 - self.inner.ready().await.map_err(|e| { 7652 7652 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7653 7653 - })?; 8857 8857 + ) -> std::result::Result< 8858 8858 + tonic::Response<super::GetRockboxVersionResponse>, 8859 8859 + tonic::Status, 8860 8860 + > { 8861 8861 + self.inner 8862 8862 + .ready() 8863 8863 + .await 8864 8864 + .map_err(|e| { 8865 8865 + tonic::Status::unknown( 8866 8866 + format!("Service was not ready: {}", e.into()), 8867 8867 + ) 8868 8868 + })?; 7654 8869 let codec = tonic::codec::ProstCodec::default(); 7655 8870 let path = http::uri::PathAndQuery::from_static( 7656 8871 "/rockbox.v1alpha1.SystemService/GetRockboxVersion", 7657 8872 ); 7658 8873 let mut req = request.into_request(); 7659 7659 - req.extensions_mut().insert(GrpcMethod::new( 7660 7660 - "rockbox.v1alpha1.SystemService", 7661 7661 - "GetRockboxVersion", 7662 7662 - )); 8874 8874 + req.extensions_mut() 8875 8875 + .insert( 8876 8876 + GrpcMethod::new( 8877 8877 + "rockbox.v1alpha1.SystemService", 8878 8878 + "GetRockboxVersion", 8879 8879 + ), 8880 8880 + ); 7663 8881 self.inner.unary(req, path, codec).await 7664 8882 } 7665 8883 pub async fn get_global_status( 7666 8884 &mut self, 7667 8885 request: impl tonic::IntoRequest<super::GetGlobalStatusRequest>, 7668 7668 - ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status> 7669 7669 - { 7670 7670 - self.inner.ready().await.map_err(|e| { 7671 7671 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7672 7672 - })?; 8886 8886 + ) -> std::result::Result< 8887 8887 + tonic::Response<super::GetGlobalStatusResponse>, 8888 8888 + tonic::Status, 8889 8889 + > { 8890 8890 + self.inner 8891 8891 + .ready() 8892 8892 + .await 8893 8893 + .map_err(|e| { 8894 8894 + tonic::Status::unknown( 8895 8895 + format!("Service was not ready: {}", e.into()), 8896 8896 + ) 8897 8897 + })?; 7673 8898 let codec = tonic::codec::ProstCodec::default(); 7674 8899 let path = http::uri::PathAndQuery::from_static( 7675 8900 "/rockbox.v1alpha1.SystemService/GetGlobalStatus", 7676 8901 ); 7677 8902 let mut req = request.into_request(); 7678 7678 - req.extensions_mut().insert(GrpcMethod::new( 7679 7679 - "rockbox.v1alpha1.SystemService", 7680 7680 - "GetGlobalStatus", 7681 7681 - )); 8903 8903 + req.extensions_mut() 8904 8904 + .insert( 8905 8905 + GrpcMethod::new("rockbox.v1alpha1.SystemService", "GetGlobalStatus"), 8906 8906 + ); 7682 8907 self.inner.unary(req, path, codec).await 7683 8908 } 7684 8909 } ··· 7690 8915 dead_code, 7691 8916 missing_docs, 7692 8917 clippy::wildcard_imports, 7693 7693 - clippy::let_unit_value 8918 8918 + clippy::let_unit_value, 7694 8919 )] 7695 8920 use tonic::codegen::*; 7696 8921 /// Generated trait containing gRPC methods that should be implemented for use with SystemServiceServer. ··· 7699 8924 async fn get_rockbox_version( 7700 8925 &self, 7701 8926 request: tonic::Request<super::GetRockboxVersionRequest>, 7702 7702 - ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status>; 8927 8927 + ) -> std::result::Result< 8928 8928 + tonic::Response<super::GetRockboxVersionResponse>, 8929 8929 + tonic::Status, 8930 8930 + >; 7703 8931 async fn get_global_status( 7704 8932 &self, 7705 8933 request: tonic::Request<super::GetGlobalStatusRequest>, 7706 7706 - ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>; 8934 8934 + ) -> std::result::Result< 8935 8935 + tonic::Response<super::GetGlobalStatusResponse>, 8936 8936 + tonic::Status, 8937 8937 + >; 7707 8938 } 7708 8939 #[derive(Debug)] 7709 8940 pub struct SystemServiceServer<T> { ··· 7726 8957 max_encoding_message_size: None, 7727 8958 } 7728 8959 } 7729 7729 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 8960 8960 + pub fn with_interceptor<F>( 8961 8961 + inner: T, 8962 8962 + interceptor: F, 8963 8963 + ) -> InterceptedService<Self, F> 7730 8964 where 7731 8965 F: tonic::service::Interceptor, 7732 8966 { ··· 7781 9015 "/rockbox.v1alpha1.SystemService/GetRockboxVersion" => { 7782 9016 #[allow(non_camel_case_types)] 7783 9017 struct GetRockboxVersionSvc<T: SystemService>(pub Arc<T>); 7784 7784 - impl<T: SystemService> 7785 7785 - tonic::server::UnaryService<super::GetRockboxVersionRequest> 7786 7786 - for GetRockboxVersionSvc<T> 7787 7787 - { 9018 9018 + impl< 9019 9019 + T: SystemService, 9020 9020 + > tonic::server::UnaryService<super::GetRockboxVersionRequest> 9021 9021 + for GetRockboxVersionSvc<T> { 7788 9022 type Response = super::GetRockboxVersionResponse; 7789 7789 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9023 9023 + type Future = BoxFuture< 9024 9024 + tonic::Response<Self::Response>, 9025 9025 + tonic::Status, 9026 9026 + >; 7790 9027 fn call( 7791 9028 &mut self, 7792 9029 request: tonic::Request<super::GetRockboxVersionRequest>, 7793 9030 ) -> Self::Future { 7794 9031 let inner = Arc::clone(&self.0); 7795 9032 let fut = async move { 7796 7796 - <T as SystemService>::get_rockbox_version(&inner, request).await 9033 9033 + <T as SystemService>::get_rockbox_version(&inner, request) 9034 9034 + .await 7797 9035 }; 7798 9036 Box::pin(fut) 7799 9037 } ··· 7823 9061 "/rockbox.v1alpha1.SystemService/GetGlobalStatus" => { 7824 9062 #[allow(non_camel_case_types)] 7825 9063 struct GetGlobalStatusSvc<T: SystemService>(pub Arc<T>); 7826 7826 - impl<T: SystemService> 7827 7827 - tonic::server::UnaryService<super::GetGlobalStatusRequest> 7828 7828 - for GetGlobalStatusSvc<T> 7829 7829 - { 9064 9064 + impl< 9065 9065 + T: SystemService, 9066 9066 + > tonic::server::UnaryService<super::GetGlobalStatusRequest> 9067 9067 + for GetGlobalStatusSvc<T> { 7830 9068 type Response = super::GetGlobalStatusResponse; 7831 7831 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9069 9069 + type Future = BoxFuture< 9070 9070 + tonic::Response<Self::Response>, 9071 9071 + tonic::Status, 9072 9072 + >; 7832 9073 fn call( 7833 9074 &mut self, 7834 9075 request: tonic::Request<super::GetGlobalStatusRequest>, 7835 9076 ) -> Self::Future { 7836 9077 let inner = Arc::clone(&self.0); 7837 9078 let fut = async move { 7838 7838 - <T as SystemService>::get_global_status(&inner, request).await 9079 9079 + <T as SystemService>::get_global_status(&inner, request) 9080 9080 + .await 7839 9081 }; 7840 9082 Box::pin(fut) 7841 9083 } ··· 7862 9104 }; 7863 9105 Box::pin(fut) 7864 9106 } 7865 7865 - _ => Box::pin(async move { 7866 7866 - let mut response = http::Response::new(empty_body()); 7867 7867 - let headers = response.headers_mut(); 7868 7868 - headers.insert( 7869 7869 - tonic::Status::GRPC_STATUS, 7870 7870 - (tonic::Code::Unimplemented as i32).into(), 7871 7871 - ); 7872 7872 - headers.insert( 7873 7873 - http::header::CONTENT_TYPE, 7874 7874 - tonic::metadata::GRPC_CONTENT_TYPE, 7875 7875 - ); 7876 7876 - Ok(response) 7877 7877 - }), 9107 9107 + _ => { 9108 9108 + Box::pin(async move { 9109 9109 + let mut response = http::Response::new(empty_body()); 9110 9110 + let headers = response.headers_mut(); 9111 9111 + headers 9112 9112 + .insert( 9113 9113 + tonic::Status::GRPC_STATUS, 9114 9114 + (tonic::Code::Unimplemented as i32).into(), 9115 9115 + ); 9116 9116 + headers 9117 9117 + .insert( 9118 9118 + http::header::CONTENT_TYPE, 9119 9119 + tonic::metadata::GRPC_CONTENT_TYPE, 9120 9120 + ); 9121 9121 + Ok(response) 9122 9122 + }) 9123 9123 + } 7878 9124 } 7879 9125 } 7880 9126 }

+2613 -1300

crates/rpc/src/api/rockbox.v1alpha1.rs

··· 43 43 dead_code, 44 44 missing_docs, 45 45 clippy::wildcard_imports, 46 46 - clippy::let_unit_value 46 46 + clippy::let_unit_value, 47 47 )] 48 48 - use tonic::codegen::http::Uri; 49 48 use tonic::codegen::*; 49 49 + use tonic::codegen::http::Uri; 50 50 #[derive(Debug, Clone)] 51 51 pub struct BrowseServiceClient<T> { 52 52 inner: tonic::client::Grpc<T>, ··· 90 90 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 91 91 >, 92 92 >, 93 93 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 94 94 - Into<StdError> + std::marker::Send + std::marker::Sync, 93 93 + <T as tonic::codegen::Service< 94 94 + http::Request<tonic::body::BoxBody>, 95 95 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 95 96 { 96 97 BrowseServiceClient::new(InterceptedService::new(inner, interceptor)) 97 98 } ··· 129 130 pub async fn tree_get_entries( 130 131 &mut self, 131 132 request: impl tonic::IntoRequest<super::TreeGetEntriesRequest>, 132 132 - ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status> 133 133 - { 134 134 - self.inner.ready().await.map_err(|e| { 135 135 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 136 136 - })?; 133 133 + ) -> std::result::Result< 134 134 + tonic::Response<super::TreeGetEntriesResponse>, 135 135 + tonic::Status, 136 136 + > { 137 137 + self.inner 138 138 + .ready() 139 139 + .await 140 140 + .map_err(|e| { 141 141 + tonic::Status::unknown( 142 142 + format!("Service was not ready: {}", e.into()), 143 143 + ) 144 144 + })?; 137 145 let codec = tonic::codec::ProstCodec::default(); 138 146 let path = http::uri::PathAndQuery::from_static( 139 147 "/rockbox.v1alpha1.BrowseService/TreeGetEntries", 140 148 ); 141 149 let mut req = request.into_request(); 142 142 - req.extensions_mut().insert(GrpcMethod::new( 143 143 - "rockbox.v1alpha1.BrowseService", 144 144 - "TreeGetEntries", 145 145 - )); 150 150 + req.extensions_mut() 151 151 + .insert( 152 152 + GrpcMethod::new("rockbox.v1alpha1.BrowseService", "TreeGetEntries"), 153 153 + ); 146 154 self.inner.unary(req, path, codec).await 147 155 } 148 156 } ··· 154 162 dead_code, 155 163 missing_docs, 156 164 clippy::wildcard_imports, 157 157 - clippy::let_unit_value 165 165 + clippy::let_unit_value, 158 166 )] 159 167 use tonic::codegen::*; 160 168 /// Generated trait containing gRPC methods that should be implemented for use with BrowseServiceServer. ··· 163 171 async fn tree_get_entries( 164 172 &self, 165 173 request: tonic::Request<super::TreeGetEntriesRequest>, 166 166 - ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status>; 174 174 + ) -> std::result::Result< 175 175 + tonic::Response<super::TreeGetEntriesResponse>, 176 176 + tonic::Status, 177 177 + >; 167 178 } 168 179 #[derive(Debug)] 169 180 pub struct BrowseServiceServer<T> { ··· 186 197 max_encoding_message_size: None, 187 198 } 188 199 } 189 189 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 200 200 + pub fn with_interceptor<F>( 201 201 + inner: T, 202 202 + interceptor: F, 203 203 + ) -> InterceptedService<Self, F> 190 204 where 191 205 F: tonic::service::Interceptor, 192 206 { ··· 241 255 "/rockbox.v1alpha1.BrowseService/TreeGetEntries" => { 242 256 #[allow(non_camel_case_types)] 243 257 struct TreeGetEntriesSvc<T: BrowseService>(pub Arc<T>); 244 244 - impl<T: BrowseService> tonic::server::UnaryService<super::TreeGetEntriesRequest> 245 245 - for TreeGetEntriesSvc<T> 246 246 - { 258 258 + impl< 259 259 + T: BrowseService, 260 260 + > tonic::server::UnaryService<super::TreeGetEntriesRequest> 261 261 + for TreeGetEntriesSvc<T> { 247 262 type Response = super::TreeGetEntriesResponse; 248 248 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 263 263 + type Future = BoxFuture< 264 264 + tonic::Response<Self::Response>, 265 265 + tonic::Status, 266 266 + >; 249 267 fn call( 250 268 &mut self, 251 269 request: tonic::Request<super::TreeGetEntriesRequest>, 252 270 ) -> Self::Future { 253 271 let inner = Arc::clone(&self.0); 254 272 let fut = async move { 255 255 - <T as BrowseService>::tree_get_entries(&inner, request).await 273 273 + <T as BrowseService>::tree_get_entries(&inner, request) 274 274 + .await 256 275 }; 257 276 Box::pin(fut) 258 277 } ··· 279 298 }; 280 299 Box::pin(fut) 281 300 } 282 282 - _ => Box::pin(async move { 283 283 - let mut response = http::Response::new(empty_body()); 284 284 - let headers = response.headers_mut(); 285 285 - headers.insert( 286 286 - tonic::Status::GRPC_STATUS, 287 287 - (tonic::Code::Unimplemented as i32).into(), 288 288 - ); 289 289 - headers.insert( 290 290 - http::header::CONTENT_TYPE, 291 291 - tonic::metadata::GRPC_CONTENT_TYPE, 292 292 - ); 293 293 - Ok(response) 294 294 - }), 301 301 + _ => { 302 302 + Box::pin(async move { 303 303 + let mut response = http::Response::new(empty_body()); 304 304 + let headers = response.headers_mut(); 305 305 + headers 306 306 + .insert( 307 307 + tonic::Status::GRPC_STATUS, 308 308 + (tonic::Code::Unimplemented as i32).into(), 309 309 + ); 310 310 + headers 311 311 + .insert( 312 312 + http::header::CONTENT_TYPE, 313 313 + tonic::metadata::GRPC_CONTENT_TYPE, 314 314 + ); 315 315 + Ok(response) 316 316 + }) 317 317 + } 295 318 } 296 319 } 297 320 } ··· 384 407 dead_code, 385 408 missing_docs, 386 409 clippy::wildcard_imports, 387 387 - clippy::let_unit_value 410 410 + clippy::let_unit_value, 388 411 )] 389 389 - use tonic::codegen::http::Uri; 390 412 use tonic::codegen::*; 413 413 + use tonic::codegen::http::Uri; 391 414 #[derive(Debug, Clone)] 392 415 pub struct DeviceServiceClient<T> { 393 416 inner: tonic::client::Grpc<T>, ··· 431 454 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 432 455 >, 433 456 >, 434 434 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 435 435 - Into<StdError> + std::marker::Send + std::marker::Sync, 457 457 + <T as tonic::codegen::Service< 458 458 + http::Request<tonic::body::BoxBody>, 459 459 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 436 460 { 437 461 DeviceServiceClient::new(InterceptedService::new(inner, interceptor)) 438 462 } ··· 470 494 pub async fn get_devices( 471 495 &mut self, 472 496 request: impl tonic::IntoRequest<super::GetDevicesRequest>, 473 473 - ) -> std::result::Result<tonic::Response<super::GetDevicesResponse>, tonic::Status> 474 474 - { 475 475 - self.inner.ready().await.map_err(|e| { 476 476 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 477 477 - })?; 497 497 + ) -> std::result::Result< 498 498 + tonic::Response<super::GetDevicesResponse>, 499 499 + tonic::Status, 500 500 + > { 501 501 + self.inner 502 502 + .ready() 503 503 + .await 504 504 + .map_err(|e| { 505 505 + tonic::Status::unknown( 506 506 + format!("Service was not ready: {}", e.into()), 507 507 + ) 508 508 + })?; 478 509 let codec = tonic::codec::ProstCodec::default(); 479 479 - let path = 480 480 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.DeviceService/GetDevices"); 510 510 + let path = http::uri::PathAndQuery::from_static( 511 511 + "/rockbox.v1alpha1.DeviceService/GetDevices", 512 512 + ); 481 513 let mut req = request.into_request(); 482 482 - req.extensions_mut().insert(GrpcMethod::new( 483 483 - "rockbox.v1alpha1.DeviceService", 484 484 - "GetDevices", 485 485 - )); 514 514 + req.extensions_mut() 515 515 + .insert(GrpcMethod::new("rockbox.v1alpha1.DeviceService", "GetDevices")); 486 516 self.inner.unary(req, path, codec).await 487 517 } 488 518 pub async fn get_device( 489 519 &mut self, 490 520 request: impl tonic::IntoRequest<super::GetDeviceRequest>, 491 491 - ) -> std::result::Result<tonic::Response<super::GetDeviceResponse>, tonic::Status> { 492 492 - self.inner.ready().await.map_err(|e| { 493 493 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 494 494 - })?; 521 521 + ) -> std::result::Result< 522 522 + tonic::Response<super::GetDeviceResponse>, 523 523 + tonic::Status, 524 524 + > { 525 525 + self.inner 526 526 + .ready() 527 527 + .await 528 528 + .map_err(|e| { 529 529 + tonic::Status::unknown( 530 530 + format!("Service was not ready: {}", e.into()), 531 531 + ) 532 532 + })?; 495 533 let codec = tonic::codec::ProstCodec::default(); 496 496 - let path = 497 497 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.DeviceService/GetDevice"); 534 534 + let path = http::uri::PathAndQuery::from_static( 535 535 + "/rockbox.v1alpha1.DeviceService/GetDevice", 536 536 + ); 498 537 let mut req = request.into_request(); 499 499 - req.extensions_mut().insert(GrpcMethod::new( 500 500 - "rockbox.v1alpha1.DeviceService", 501 501 - "GetDevice", 502 502 - )); 538 538 + req.extensions_mut() 539 539 + .insert(GrpcMethod::new("rockbox.v1alpha1.DeviceService", "GetDevice")); 503 540 self.inner.unary(req, path, codec).await 504 541 } 505 542 pub async fn connect_device( 506 543 &mut self, 507 544 request: impl tonic::IntoRequest<super::ConnectDeviceRequest>, 508 508 - ) -> std::result::Result<tonic::Response<super::ConnectDeviceResponse>, tonic::Status> 509 509 - { 510 510 - self.inner.ready().await.map_err(|e| { 511 511 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 512 512 - })?; 545 545 + ) -> std::result::Result< 546 546 + tonic::Response<super::ConnectDeviceResponse>, 547 547 + tonic::Status, 548 548 + > { 549 549 + self.inner 550 550 + .ready() 551 551 + .await 552 552 + .map_err(|e| { 553 553 + tonic::Status::unknown( 554 554 + format!("Service was not ready: {}", e.into()), 555 555 + ) 556 556 + })?; 513 557 let codec = tonic::codec::ProstCodec::default(); 514 558 let path = http::uri::PathAndQuery::from_static( 515 559 "/rockbox.v1alpha1.DeviceService/ConnectDevice", 516 560 ); 517 561 let mut req = request.into_request(); 518 518 - req.extensions_mut().insert(GrpcMethod::new( 519 519 - "rockbox.v1alpha1.DeviceService", 520 520 - "ConnectDevice", 521 521 - )); 562 562 + req.extensions_mut() 563 563 + .insert( 564 564 + GrpcMethod::new("rockbox.v1alpha1.DeviceService", "ConnectDevice"), 565 565 + ); 522 566 self.inner.unary(req, path, codec).await 523 567 } 524 568 pub async fn disconnect_device( 525 569 &mut self, 526 570 request: impl tonic::IntoRequest<super::DisconnectDeviceRequest>, 527 527 - ) -> std::result::Result<tonic::Response<super::DisconnectDeviceResponse>, tonic::Status> 528 528 - { 529 529 - self.inner.ready().await.map_err(|e| { 530 530 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 531 531 - })?; 571 571 + ) -> std::result::Result< 572 572 + tonic::Response<super::DisconnectDeviceResponse>, 573 573 + tonic::Status, 574 574 + > { 575 575 + self.inner 576 576 + .ready() 577 577 + .await 578 578 + .map_err(|e| { 579 579 + tonic::Status::unknown( 580 580 + format!("Service was not ready: {}", e.into()), 581 581 + ) 582 582 + })?; 532 583 let codec = tonic::codec::ProstCodec::default(); 533 584 let path = http::uri::PathAndQuery::from_static( 534 585 "/rockbox.v1alpha1.DeviceService/DisconnectDevice", 535 586 ); 536 587 let mut req = request.into_request(); 537 537 - req.extensions_mut().insert(GrpcMethod::new( 538 538 - "rockbox.v1alpha1.DeviceService", 539 539 - "DisconnectDevice", 540 540 - )); 588 588 + req.extensions_mut() 589 589 + .insert( 590 590 + GrpcMethod::new("rockbox.v1alpha1.DeviceService", "DisconnectDevice"), 591 591 + ); 541 592 self.inner.unary(req, path, codec).await 542 593 } 543 594 } ··· 549 600 dead_code, 550 601 missing_docs, 551 602 clippy::wildcard_imports, 552 552 - clippy::let_unit_value 603 603 + clippy::let_unit_value, 553 604 )] 554 605 use tonic::codegen::*; 555 606 /// Generated trait containing gRPC methods that should be implemented for use with DeviceServiceServer. ··· 558 609 async fn get_devices( 559 610 &self, 560 611 request: tonic::Request<super::GetDevicesRequest>, 561 561 - ) -> std::result::Result<tonic::Response<super::GetDevicesResponse>, tonic::Status>; 612 612 + ) -> std::result::Result< 613 613 + tonic::Response<super::GetDevicesResponse>, 614 614 + tonic::Status, 615 615 + >; 562 616 async fn get_device( 563 617 &self, 564 618 request: tonic::Request<super::GetDeviceRequest>, 565 565 - ) -> std::result::Result<tonic::Response<super::GetDeviceResponse>, tonic::Status>; 619 619 + ) -> std::result::Result< 620 620 + tonic::Response<super::GetDeviceResponse>, 621 621 + tonic::Status, 622 622 + >; 566 623 async fn connect_device( 567 624 &self, 568 625 request: tonic::Request<super::ConnectDeviceRequest>, 569 569 - ) -> std::result::Result<tonic::Response<super::ConnectDeviceResponse>, tonic::Status>; 626 626 + ) -> std::result::Result< 627 627 + tonic::Response<super::ConnectDeviceResponse>, 628 628 + tonic::Status, 629 629 + >; 570 630 async fn disconnect_device( 571 631 &self, 572 632 request: tonic::Request<super::DisconnectDeviceRequest>, 573 573 - ) -> std::result::Result<tonic::Response<super::DisconnectDeviceResponse>, tonic::Status>; 633 633 + ) -> std::result::Result< 634 634 + tonic::Response<super::DisconnectDeviceResponse>, 635 635 + tonic::Status, 636 636 + >; 574 637 } 575 638 #[derive(Debug)] 576 639 pub struct DeviceServiceServer<T> { ··· 593 656 max_encoding_message_size: None, 594 657 } 595 658 } 596 596 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 659 659 + pub fn with_interceptor<F>( 660 660 + inner: T, 661 661 + interceptor: F, 662 662 + ) -> InterceptedService<Self, F> 597 663 where 598 664 F: tonic::service::Interceptor, 599 665 { ··· 648 714 "/rockbox.v1alpha1.DeviceService/GetDevices" => { 649 715 #[allow(non_camel_case_types)] 650 716 struct GetDevicesSvc<T: DeviceService>(pub Arc<T>); 651 651 - impl<T: DeviceService> tonic::server::UnaryService<super::GetDevicesRequest> for GetDevicesSvc<T> { 717 717 + impl< 718 718 + T: DeviceService, 719 719 + > tonic::server::UnaryService<super::GetDevicesRequest> 720 720 + for GetDevicesSvc<T> { 652 721 type Response = super::GetDevicesResponse; 653 653 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 722 722 + type Future = BoxFuture< 723 723 + tonic::Response<Self::Response>, 724 724 + tonic::Status, 725 725 + >; 654 726 fn call( 655 727 &mut self, 656 728 request: tonic::Request<super::GetDevicesRequest>, ··· 687 759 "/rockbox.v1alpha1.DeviceService/GetDevice" => { 688 760 #[allow(non_camel_case_types)] 689 761 struct GetDeviceSvc<T: DeviceService>(pub Arc<T>); 690 690 - impl<T: DeviceService> tonic::server::UnaryService<super::GetDeviceRequest> for GetDeviceSvc<T> { 762 762 + impl< 763 763 + T: DeviceService, 764 764 + > tonic::server::UnaryService<super::GetDeviceRequest> 765 765 + for GetDeviceSvc<T> { 691 766 type Response = super::GetDeviceResponse; 692 692 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 767 767 + type Future = BoxFuture< 768 768 + tonic::Response<Self::Response>, 769 769 + tonic::Status, 770 770 + >; 693 771 fn call( 694 772 &mut self, 695 773 request: tonic::Request<super::GetDeviceRequest>, ··· 726 804 "/rockbox.v1alpha1.DeviceService/ConnectDevice" => { 727 805 #[allow(non_camel_case_types)] 728 806 struct ConnectDeviceSvc<T: DeviceService>(pub Arc<T>); 729 729 - impl<T: DeviceService> tonic::server::UnaryService<super::ConnectDeviceRequest> 730 730 - for ConnectDeviceSvc<T> 731 731 - { 807 807 + impl< 808 808 + T: DeviceService, 809 809 + > tonic::server::UnaryService<super::ConnectDeviceRequest> 810 810 + for ConnectDeviceSvc<T> { 732 811 type Response = super::ConnectDeviceResponse; 733 733 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 812 812 + type Future = BoxFuture< 813 813 + tonic::Response<Self::Response>, 814 814 + tonic::Status, 815 815 + >; 734 816 fn call( 735 817 &mut self, 736 818 request: tonic::Request<super::ConnectDeviceRequest>, ··· 767 849 "/rockbox.v1alpha1.DeviceService/DisconnectDevice" => { 768 850 #[allow(non_camel_case_types)] 769 851 struct DisconnectDeviceSvc<T: DeviceService>(pub Arc<T>); 770 770 - impl<T: DeviceService> 771 771 - tonic::server::UnaryService<super::DisconnectDeviceRequest> 772 772 - for DisconnectDeviceSvc<T> 773 773 - { 852 852 + impl< 853 853 + T: DeviceService, 854 854 + > tonic::server::UnaryService<super::DisconnectDeviceRequest> 855 855 + for DisconnectDeviceSvc<T> { 774 856 type Response = super::DisconnectDeviceResponse; 775 775 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 857 857 + type Future = BoxFuture< 858 858 + tonic::Response<Self::Response>, 859 859 + tonic::Status, 860 860 + >; 776 861 fn call( 777 862 &mut self, 778 863 request: tonic::Request<super::DisconnectDeviceRequest>, 779 864 ) -> Self::Future { 780 865 let inner = Arc::clone(&self.0); 781 866 let fut = async move { 782 782 - <T as DeviceService>::disconnect_device(&inner, request).await 867 867 + <T as DeviceService>::disconnect_device(&inner, request) 868 868 + .await 783 869 }; 784 870 Box::pin(fut) 785 871 } ··· 806 892 }; 807 893 Box::pin(fut) 808 894 } 809 809 - _ => Box::pin(async move { 810 810 - let mut response = http::Response::new(empty_body()); 811 811 - let headers = response.headers_mut(); 812 812 - headers.insert( 813 813 - tonic::Status::GRPC_STATUS, 814 814 - (tonic::Code::Unimplemented as i32).into(), 815 815 - ); 816 816 - headers.insert( 817 817 - http::header::CONTENT_TYPE, 818 818 - tonic::metadata::GRPC_CONTENT_TYPE, 819 819 - ); 820 820 - Ok(response) 821 821 - }), 895 895 + _ => { 896 896 + Box::pin(async move { 897 897 + let mut response = http::Response::new(empty_body()); 898 898 + let headers = response.headers_mut(); 899 899 + headers 900 900 + .insert( 901 901 + tonic::Status::GRPC_STATUS, 902 902 + (tonic::Code::Unimplemented as i32).into(), 903 903 + ); 904 904 + headers 905 905 + .insert( 906 906 + http::header::CONTENT_TYPE, 907 907 + tonic::metadata::GRPC_CONTENT_TYPE, 908 908 + ); 909 909 + Ok(response) 910 910 + }) 911 911 + } 822 912 } 823 913 } 824 914 } ··· 1046 1136 dead_code, 1047 1137 missing_docs, 1048 1138 clippy::wildcard_imports, 1049 1049 - clippy::let_unit_value 1139 1139 + clippy::let_unit_value, 1050 1140 )] 1051 1051 - use tonic::codegen::http::Uri; 1052 1141 use tonic::codegen::*; 1142 1142 + use tonic::codegen::http::Uri; 1053 1143 #[derive(Debug, Clone)] 1054 1144 pub struct LibraryServiceClient<T> { 1055 1145 inner: tonic::client::Grpc<T>, ··· 1093 1183 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 1094 1184 >, 1095 1185 >, 1096 1096 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 1097 1097 - Into<StdError> + std::marker::Send + std::marker::Sync, 1186 1186 + <T as tonic::codegen::Service< 1187 1187 + http::Request<tonic::body::BoxBody>, 1188 1188 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 1098 1189 { 1099 1190 LibraryServiceClient::new(InterceptedService::new(inner, interceptor)) 1100 1191 } ··· 1132 1223 pub async fn get_albums( 1133 1224 &mut self, 1134 1225 request: impl tonic::IntoRequest<super::GetAlbumsRequest>, 1135 1135 - ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status> { 1136 1136 - self.inner.ready().await.map_err(|e| { 1137 1137 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1138 1138 - })?; 1226 1226 + ) -> std::result::Result< 1227 1227 + tonic::Response<super::GetAlbumsResponse>, 1228 1228 + tonic::Status, 1229 1229 + > { 1230 1230 + self.inner 1231 1231 + .ready() 1232 1232 + .await 1233 1233 + .map_err(|e| { 1234 1234 + tonic::Status::unknown( 1235 1235 + format!("Service was not ready: {}", e.into()), 1236 1236 + ) 1237 1237 + })?; 1139 1238 let codec = tonic::codec::ProstCodec::default(); 1140 1140 - let path = 1141 1141 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbums"); 1239 1239 + let path = http::uri::PathAndQuery::from_static( 1240 1240 + "/rockbox.v1alpha1.LibraryService/GetAlbums", 1241 1241 + ); 1142 1242 let mut req = request.into_request(); 1143 1143 - req.extensions_mut().insert(GrpcMethod::new( 1144 1144 - "rockbox.v1alpha1.LibraryService", 1145 1145 - "GetAlbums", 1146 1146 - )); 1243 1243 + req.extensions_mut() 1244 1244 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbums")); 1147 1245 self.inner.unary(req, path, codec).await 1148 1246 } 1149 1247 pub async fn get_artists( 1150 1248 &mut self, 1151 1249 request: impl tonic::IntoRequest<super::GetArtistsRequest>, 1152 1152 - ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status> 1153 1153 - { 1154 1154 - self.inner.ready().await.map_err(|e| { 1155 1155 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1156 1156 - })?; 1250 1250 + ) -> std::result::Result< 1251 1251 + tonic::Response<super::GetArtistsResponse>, 1252 1252 + tonic::Status, 1253 1253 + > { 1254 1254 + self.inner 1255 1255 + .ready() 1256 1256 + .await 1257 1257 + .map_err(|e| { 1258 1258 + tonic::Status::unknown( 1259 1259 + format!("Service was not ready: {}", e.into()), 1260 1260 + ) 1261 1261 + })?; 1157 1262 let codec = tonic::codec::ProstCodec::default(); 1158 1158 - let path = 1159 1159 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtists"); 1263 1263 + let path = http::uri::PathAndQuery::from_static( 1264 1264 + "/rockbox.v1alpha1.LibraryService/GetArtists", 1265 1265 + ); 1160 1266 let mut req = request.into_request(); 1161 1161 - req.extensions_mut().insert(GrpcMethod::new( 1162 1162 - "rockbox.v1alpha1.LibraryService", 1163 1163 - "GetArtists", 1164 1164 - )); 1267 1267 + req.extensions_mut() 1268 1268 + .insert( 1269 1269 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtists"), 1270 1270 + ); 1165 1271 self.inner.unary(req, path, codec).await 1166 1272 } 1167 1273 pub async fn get_tracks( 1168 1274 &mut self, 1169 1275 request: impl tonic::IntoRequest<super::GetTracksRequest>, 1170 1170 - ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status> { 1171 1171 - self.inner.ready().await.map_err(|e| { 1172 1172 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1173 1173 - })?; 1276 1276 + ) -> std::result::Result< 1277 1277 + tonic::Response<super::GetTracksResponse>, 1278 1278 + tonic::Status, 1279 1279 + > { 1280 1280 + self.inner 1281 1281 + .ready() 1282 1282 + .await 1283 1283 + .map_err(|e| { 1284 1284 + tonic::Status::unknown( 1285 1285 + format!("Service was not ready: {}", e.into()), 1286 1286 + ) 1287 1287 + })?; 1174 1288 let codec = tonic::codec::ProstCodec::default(); 1175 1175 - let path = 1176 1176 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTracks"); 1289 1289 + let path = http::uri::PathAndQuery::from_static( 1290 1290 + "/rockbox.v1alpha1.LibraryService/GetTracks", 1291 1291 + ); 1177 1292 let mut req = request.into_request(); 1178 1178 - req.extensions_mut().insert(GrpcMethod::new( 1179 1179 - "rockbox.v1alpha1.LibraryService", 1180 1180 - "GetTracks", 1181 1181 - )); 1293 1293 + req.extensions_mut() 1294 1294 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTracks")); 1182 1295 self.inner.unary(req, path, codec).await 1183 1296 } 1184 1297 pub async fn get_album( 1185 1298 &mut self, 1186 1299 request: impl tonic::IntoRequest<super::GetAlbumRequest>, 1187 1187 - ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status> { 1188 1188 - self.inner.ready().await.map_err(|e| { 1189 1189 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1190 1190 - })?; 1300 1300 + ) -> std::result::Result< 1301 1301 + tonic::Response<super::GetAlbumResponse>, 1302 1302 + tonic::Status, 1303 1303 + > { 1304 1304 + self.inner 1305 1305 + .ready() 1306 1306 + .await 1307 1307 + .map_err(|e| { 1308 1308 + tonic::Status::unknown( 1309 1309 + format!("Service was not ready: {}", e.into()), 1310 1310 + ) 1311 1311 + })?; 1191 1312 let codec = tonic::codec::ProstCodec::default(); 1192 1192 - let path = 1193 1193 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbum"); 1313 1313 + let path = http::uri::PathAndQuery::from_static( 1314 1314 + "/rockbox.v1alpha1.LibraryService/GetAlbum", 1315 1315 + ); 1194 1316 let mut req = request.into_request(); 1195 1195 - req.extensions_mut().insert(GrpcMethod::new( 1196 1196 - "rockbox.v1alpha1.LibraryService", 1197 1197 - "GetAlbum", 1198 1198 - )); 1317 1317 + req.extensions_mut() 1318 1318 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbum")); 1199 1319 self.inner.unary(req, path, codec).await 1200 1320 } 1201 1321 pub async fn get_artist( 1202 1322 &mut self, 1203 1323 request: impl tonic::IntoRequest<super::GetArtistRequest>, 1204 1204 - ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status> { 1205 1205 - self.inner.ready().await.map_err(|e| { 1206 1206 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1207 1207 - })?; 1324 1324 + ) -> std::result::Result< 1325 1325 + tonic::Response<super::GetArtistResponse>, 1326 1326 + tonic::Status, 1327 1327 + > { 1328 1328 + self.inner 1329 1329 + .ready() 1330 1330 + .await 1331 1331 + .map_err(|e| { 1332 1332 + tonic::Status::unknown( 1333 1333 + format!("Service was not ready: {}", e.into()), 1334 1334 + ) 1335 1335 + })?; 1208 1336 let codec = tonic::codec::ProstCodec::default(); 1209 1209 - let path = 1210 1210 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtist"); 1337 1337 + let path = http::uri::PathAndQuery::from_static( 1338 1338 + "/rockbox.v1alpha1.LibraryService/GetArtist", 1339 1339 + ); 1211 1340 let mut req = request.into_request(); 1212 1212 - req.extensions_mut().insert(GrpcMethod::new( 1213 1213 - "rockbox.v1alpha1.LibraryService", 1214 1214 - "GetArtist", 1215 1215 - )); 1341 1341 + req.extensions_mut() 1342 1342 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtist")); 1216 1343 self.inner.unary(req, path, codec).await 1217 1344 } 1218 1345 pub async fn get_track( 1219 1346 &mut self, 1220 1347 request: impl tonic::IntoRequest<super::GetTrackRequest>, 1221 1221 - ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status> { 1222 1222 - self.inner.ready().await.map_err(|e| { 1223 1223 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1224 1224 - })?; 1348 1348 + ) -> std::result::Result< 1349 1349 + tonic::Response<super::GetTrackResponse>, 1350 1350 + tonic::Status, 1351 1351 + > { 1352 1352 + self.inner 1353 1353 + .ready() 1354 1354 + .await 1355 1355 + .map_err(|e| { 1356 1356 + tonic::Status::unknown( 1357 1357 + format!("Service was not ready: {}", e.into()), 1358 1358 + ) 1359 1359 + })?; 1225 1360 let codec = tonic::codec::ProstCodec::default(); 1226 1226 - let path = 1227 1227 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTrack"); 1361 1361 + let path = http::uri::PathAndQuery::from_static( 1362 1362 + "/rockbox.v1alpha1.LibraryService/GetTrack", 1363 1363 + ); 1228 1364 let mut req = request.into_request(); 1229 1229 - req.extensions_mut().insert(GrpcMethod::new( 1230 1230 - "rockbox.v1alpha1.LibraryService", 1231 1231 - "GetTrack", 1232 1232 - )); 1365 1365 + req.extensions_mut() 1366 1366 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTrack")); 1233 1367 self.inner.unary(req, path, codec).await 1234 1368 } 1235 1369 pub async fn like_track( 1236 1370 &mut self, 1237 1371 request: impl tonic::IntoRequest<super::LikeTrackRequest>, 1238 1238 - ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status> { 1239 1239 - self.inner.ready().await.map_err(|e| { 1240 1240 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1241 1241 - })?; 1372 1372 + ) -> std::result::Result< 1373 1373 + tonic::Response<super::LikeTrackResponse>, 1374 1374 + tonic::Status, 1375 1375 + > { 1376 1376 + self.inner 1377 1377 + .ready() 1378 1378 + .await 1379 1379 + .map_err(|e| { 1380 1380 + tonic::Status::unknown( 1381 1381 + format!("Service was not ready: {}", e.into()), 1382 1382 + ) 1383 1383 + })?; 1242 1384 let codec = tonic::codec::ProstCodec::default(); 1243 1243 - let path = 1244 1244 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeTrack"); 1385 1385 + let path = http::uri::PathAndQuery::from_static( 1386 1386 + "/rockbox.v1alpha1.LibraryService/LikeTrack", 1387 1387 + ); 1245 1388 let mut req = request.into_request(); 1246 1246 - req.extensions_mut().insert(GrpcMethod::new( 1247 1247 - "rockbox.v1alpha1.LibraryService", 1248 1248 - "LikeTrack", 1249 1249 - )); 1389 1389 + req.extensions_mut() 1390 1390 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeTrack")); 1250 1391 self.inner.unary(req, path, codec).await 1251 1392 } 1252 1393 pub async fn unlike_track( 1253 1394 &mut self, 1254 1395 request: impl tonic::IntoRequest<super::UnlikeTrackRequest>, 1255 1255 - ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status> 1256 1256 - { 1257 1257 - self.inner.ready().await.map_err(|e| { 1258 1258 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1259 1259 - })?; 1396 1396 + ) -> std::result::Result< 1397 1397 + tonic::Response<super::UnlikeTrackResponse>, 1398 1398 + tonic::Status, 1399 1399 + > { 1400 1400 + self.inner 1401 1401 + .ready() 1402 1402 + .await 1403 1403 + .map_err(|e| { 1404 1404 + tonic::Status::unknown( 1405 1405 + format!("Service was not ready: {}", e.into()), 1406 1406 + ) 1407 1407 + })?; 1260 1408 let codec = tonic::codec::ProstCodec::default(); 1261 1409 let path = http::uri::PathAndQuery::from_static( 1262 1410 "/rockbox.v1alpha1.LibraryService/UnlikeTrack", 1263 1411 ); 1264 1412 let mut req = request.into_request(); 1265 1265 - req.extensions_mut().insert(GrpcMethod::new( 1266 1266 - "rockbox.v1alpha1.LibraryService", 1267 1267 - "UnlikeTrack", 1268 1268 - )); 1413 1413 + req.extensions_mut() 1414 1414 + .insert( 1415 1415 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeTrack"), 1416 1416 + ); 1269 1417 self.inner.unary(req, path, codec).await 1270 1418 } 1271 1419 pub async fn like_album( 1272 1420 &mut self, 1273 1421 request: impl tonic::IntoRequest<super::LikeAlbumRequest>, 1274 1274 - ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status> { 1275 1275 - self.inner.ready().await.map_err(|e| { 1276 1276 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1277 1277 - })?; 1422 1422 + ) -> std::result::Result< 1423 1423 + tonic::Response<super::LikeAlbumResponse>, 1424 1424 + tonic::Status, 1425 1425 + > { 1426 1426 + self.inner 1427 1427 + .ready() 1428 1428 + .await 1429 1429 + .map_err(|e| { 1430 1430 + tonic::Status::unknown( 1431 1431 + format!("Service was not ready: {}", e.into()), 1432 1432 + ) 1433 1433 + })?; 1278 1434 let codec = tonic::codec::ProstCodec::default(); 1279 1279 - let path = 1280 1280 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeAlbum"); 1435 1435 + let path = http::uri::PathAndQuery::from_static( 1436 1436 + "/rockbox.v1alpha1.LibraryService/LikeAlbum", 1437 1437 + ); 1281 1438 let mut req = request.into_request(); 1282 1282 - req.extensions_mut().insert(GrpcMethod::new( 1283 1283 - "rockbox.v1alpha1.LibraryService", 1284 1284 - "LikeAlbum", 1285 1285 - )); 1439 1439 + req.extensions_mut() 1440 1440 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeAlbum")); 1286 1441 self.inner.unary(req, path, codec).await 1287 1442 } 1288 1443 pub async fn unlike_album( 1289 1444 &mut self, 1290 1445 request: impl tonic::IntoRequest<super::UnlikeAlbumRequest>, 1291 1291 - ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status> 1292 1292 - { 1293 1293 - self.inner.ready().await.map_err(|e| { 1294 1294 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1295 1295 - })?; 1446 1446 + ) -> std::result::Result< 1447 1447 + tonic::Response<super::UnlikeAlbumResponse>, 1448 1448 + tonic::Status, 1449 1449 + > { 1450 1450 + self.inner 1451 1451 + .ready() 1452 1452 + .await 1453 1453 + .map_err(|e| { 1454 1454 + tonic::Status::unknown( 1455 1455 + format!("Service was not ready: {}", e.into()), 1456 1456 + ) 1457 1457 + })?; 1296 1458 let codec = tonic::codec::ProstCodec::default(); 1297 1459 let path = http::uri::PathAndQuery::from_static( 1298 1460 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum", 1299 1461 ); 1300 1462 let mut req = request.into_request(); 1301 1301 - req.extensions_mut().insert(GrpcMethod::new( 1302 1302 - "rockbox.v1alpha1.LibraryService", 1303 1303 - "UnlikeAlbum", 1304 1304 - )); 1463 1463 + req.extensions_mut() 1464 1464 + .insert( 1465 1465 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeAlbum"), 1466 1466 + ); 1305 1467 self.inner.unary(req, path, codec).await 1306 1468 } 1307 1469 pub async fn get_liked_tracks( 1308 1470 &mut self, 1309 1471 request: impl tonic::IntoRequest<super::GetLikedTracksRequest>, 1310 1310 - ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status> 1311 1311 - { 1312 1312 - self.inner.ready().await.map_err(|e| { 1313 1313 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1314 1314 - })?; 1472 1472 + ) -> std::result::Result< 1473 1473 + tonic::Response<super::GetLikedTracksResponse>, 1474 1474 + tonic::Status, 1475 1475 + > { 1476 1476 + self.inner 1477 1477 + .ready() 1478 1478 + .await 1479 1479 + .map_err(|e| { 1480 1480 + tonic::Status::unknown( 1481 1481 + format!("Service was not ready: {}", e.into()), 1482 1482 + ) 1483 1483 + })?; 1315 1484 let codec = tonic::codec::ProstCodec::default(); 1316 1485 let path = http::uri::PathAndQuery::from_static( 1317 1486 "/rockbox.v1alpha1.LibraryService/GetLikedTracks", 1318 1487 ); 1319 1488 let mut req = request.into_request(); 1320 1320 - req.extensions_mut().insert(GrpcMethod::new( 1321 1321 - "rockbox.v1alpha1.LibraryService", 1322 1322 - "GetLikedTracks", 1323 1323 - )); 1489 1489 + req.extensions_mut() 1490 1490 + .insert( 1491 1491 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedTracks"), 1492 1492 + ); 1324 1493 self.inner.unary(req, path, codec).await 1325 1494 } 1326 1495 pub async fn get_liked_albums( 1327 1496 &mut self, 1328 1497 request: impl tonic::IntoRequest<super::GetLikedAlbumsRequest>, 1329 1329 - ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status> 1330 1330 - { 1331 1331 - self.inner.ready().await.map_err(|e| { 1332 1332 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1333 1333 - })?; 1498 1498 + ) -> std::result::Result< 1499 1499 + tonic::Response<super::GetLikedAlbumsResponse>, 1500 1500 + tonic::Status, 1501 1501 + > { 1502 1502 + self.inner 1503 1503 + .ready() 1504 1504 + .await 1505 1505 + .map_err(|e| { 1506 1506 + tonic::Status::unknown( 1507 1507 + format!("Service was not ready: {}", e.into()), 1508 1508 + ) 1509 1509 + })?; 1334 1510 let codec = tonic::codec::ProstCodec::default(); 1335 1511 let path = http::uri::PathAndQuery::from_static( 1336 1512 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums", 1337 1513 ); 1338 1514 let mut req = request.into_request(); 1339 1339 - req.extensions_mut().insert(GrpcMethod::new( 1340 1340 - "rockbox.v1alpha1.LibraryService", 1341 1341 - "GetLikedAlbums", 1342 1342 - )); 1515 1515 + req.extensions_mut() 1516 1516 + .insert( 1517 1517 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedAlbums"), 1518 1518 + ); 1343 1519 self.inner.unary(req, path, codec).await 1344 1520 } 1345 1521 pub async fn scan_library( 1346 1522 &mut self, 1347 1523 request: impl tonic::IntoRequest<super::ScanLibraryRequest>, 1348 1348 - ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status> 1349 1349 - { 1350 1350 - self.inner.ready().await.map_err(|e| { 1351 1351 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1352 1352 - })?; 1524 1524 + ) -> std::result::Result< 1525 1525 + tonic::Response<super::ScanLibraryResponse>, 1526 1526 + tonic::Status, 1527 1527 + > { 1528 1528 + self.inner 1529 1529 + .ready() 1530 1530 + .await 1531 1531 + .map_err(|e| { 1532 1532 + tonic::Status::unknown( 1533 1533 + format!("Service was not ready: {}", e.into()), 1534 1534 + ) 1535 1535 + })?; 1353 1536 let codec = tonic::codec::ProstCodec::default(); 1354 1537 let path = http::uri::PathAndQuery::from_static( 1355 1538 "/rockbox.v1alpha1.LibraryService/ScanLibrary", 1356 1539 ); 1357 1540 let mut req = request.into_request(); 1358 1358 - req.extensions_mut().insert(GrpcMethod::new( 1359 1359 - "rockbox.v1alpha1.LibraryService", 1360 1360 - "ScanLibrary", 1361 1361 - )); 1541 1541 + req.extensions_mut() 1542 1542 + .insert( 1543 1543 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "ScanLibrary"), 1544 1544 + ); 1362 1545 self.inner.unary(req, path, codec).await 1363 1546 } 1364 1547 pub async fn search( 1365 1548 &mut self, 1366 1549 request: impl tonic::IntoRequest<super::SearchRequest>, 1367 1550 ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> { 1368 1368 - self.inner.ready().await.map_err(|e| { 1369 1369 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 1370 1370 - })?; 1551 1551 + self.inner 1552 1552 + .ready() 1553 1553 + .await 1554 1554 + .map_err(|e| { 1555 1555 + tonic::Status::unknown( 1556 1556 + format!("Service was not ready: {}", e.into()), 1557 1557 + ) 1558 1558 + })?; 1371 1559 let codec = tonic::codec::ProstCodec::default(); 1372 1372 - let path = 1373 1373 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/Search"); 1560 1560 + let path = http::uri::PathAndQuery::from_static( 1561 1561 + "/rockbox.v1alpha1.LibraryService/Search", 1562 1562 + ); 1374 1563 let mut req = request.into_request(); 1375 1564 req.extensions_mut() 1376 1565 .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "Search")); ··· 1385 1574 dead_code, 1386 1575 missing_docs, 1387 1576 clippy::wildcard_imports, 1388 1388 - clippy::let_unit_value 1577 1577 + clippy::let_unit_value, 1389 1578 )] 1390 1579 use tonic::codegen::*; 1391 1580 /// Generated trait containing gRPC methods that should be implemented for use with LibraryServiceServer. ··· 1394 1583 async fn get_albums( 1395 1584 &self, 1396 1585 request: tonic::Request<super::GetAlbumsRequest>, 1397 1397 - ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status>; 1586 1586 + ) -> std::result::Result< 1587 1587 + tonic::Response<super::GetAlbumsResponse>, 1588 1588 + tonic::Status, 1589 1589 + >; 1398 1590 async fn get_artists( 1399 1591 &self, 1400 1592 request: tonic::Request<super::GetArtistsRequest>, 1401 1401 - ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status>; 1593 1593 + ) -> std::result::Result< 1594 1594 + tonic::Response<super::GetArtistsResponse>, 1595 1595 + tonic::Status, 1596 1596 + >; 1402 1597 async fn get_tracks( 1403 1598 &self, 1404 1599 request: tonic::Request<super::GetTracksRequest>, 1405 1405 - ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status>; 1600 1600 + ) -> std::result::Result< 1601 1601 + tonic::Response<super::GetTracksResponse>, 1602 1602 + tonic::Status, 1603 1603 + >; 1406 1604 async fn get_album( 1407 1605 &self, 1408 1606 request: tonic::Request<super::GetAlbumRequest>, 1409 1409 - ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status>; 1607 1607 + ) -> std::result::Result< 1608 1608 + tonic::Response<super::GetAlbumResponse>, 1609 1609 + tonic::Status, 1610 1610 + >; 1410 1611 async fn get_artist( 1411 1612 &self, 1412 1613 request: tonic::Request<super::GetArtistRequest>, 1413 1413 - ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status>; 1614 1614 + ) -> std::result::Result< 1615 1615 + tonic::Response<super::GetArtistResponse>, 1616 1616 + tonic::Status, 1617 1617 + >; 1414 1618 async fn get_track( 1415 1619 &self, 1416 1620 request: tonic::Request<super::GetTrackRequest>, 1417 1417 - ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status>; 1621 1621 + ) -> std::result::Result< 1622 1622 + tonic::Response<super::GetTrackResponse>, 1623 1623 + tonic::Status, 1624 1624 + >; 1418 1625 async fn like_track( 1419 1626 &self, 1420 1627 request: tonic::Request<super::LikeTrackRequest>, 1421 1421 - ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status>; 1628 1628 + ) -> std::result::Result< 1629 1629 + tonic::Response<super::LikeTrackResponse>, 1630 1630 + tonic::Status, 1631 1631 + >; 1422 1632 async fn unlike_track( 1423 1633 &self, 1424 1634 request: tonic::Request<super::UnlikeTrackRequest>, 1425 1425 - ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status>; 1635 1635 + ) -> std::result::Result< 1636 1636 + tonic::Response<super::UnlikeTrackResponse>, 1637 1637 + tonic::Status, 1638 1638 + >; 1426 1639 async fn like_album( 1427 1640 &self, 1428 1641 request: tonic::Request<super::LikeAlbumRequest>, 1429 1429 - ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status>; 1642 1642 + ) -> std::result::Result< 1643 1643 + tonic::Response<super::LikeAlbumResponse>, 1644 1644 + tonic::Status, 1645 1645 + >; 1430 1646 async fn unlike_album( 1431 1647 &self, 1432 1648 request: tonic::Request<super::UnlikeAlbumRequest>, 1433 1433 - ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status>; 1649 1649 + ) -> std::result::Result< 1650 1650 + tonic::Response<super::UnlikeAlbumResponse>, 1651 1651 + tonic::Status, 1652 1652 + >; 1434 1653 async fn get_liked_tracks( 1435 1654 &self, 1436 1655 request: tonic::Request<super::GetLikedTracksRequest>, 1437 1437 - ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status>; 1656 1656 + ) -> std::result::Result< 1657 1657 + tonic::Response<super::GetLikedTracksResponse>, 1658 1658 + tonic::Status, 1659 1659 + >; 1438 1660 async fn get_liked_albums( 1439 1661 &self, 1440 1662 request: tonic::Request<super::GetLikedAlbumsRequest>, 1441 1441 - ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status>; 1663 1663 + ) -> std::result::Result< 1664 1664 + tonic::Response<super::GetLikedAlbumsResponse>, 1665 1665 + tonic::Status, 1666 1666 + >; 1442 1667 async fn scan_library( 1443 1668 &self, 1444 1669 request: tonic::Request<super::ScanLibraryRequest>, 1445 1445 - ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>; 1670 1670 + ) -> std::result::Result< 1671 1671 + tonic::Response<super::ScanLibraryResponse>, 1672 1672 + tonic::Status, 1673 1673 + >; 1446 1674 async fn search( 1447 1675 &self, 1448 1676 request: tonic::Request<super::SearchRequest>, ··· 1469 1697 max_encoding_message_size: None, 1470 1698 } 1471 1699 } 1472 1472 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1700 1700 + pub fn with_interceptor<F>( 1701 1701 + inner: T, 1702 1702 + interceptor: F, 1703 1703 + ) -> InterceptedService<Self, F> 1473 1704 where 1474 1705 F: tonic::service::Interceptor, 1475 1706 { ··· 1524 1755 "/rockbox.v1alpha1.LibraryService/GetAlbums" => { 1525 1756 #[allow(non_camel_case_types)] 1526 1757 struct GetAlbumsSvc<T: LibraryService>(pub Arc<T>); 1527 1527 - impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumsRequest> for GetAlbumsSvc<T> { 1758 1758 + impl< 1759 1759 + T: LibraryService, 1760 1760 + > tonic::server::UnaryService<super::GetAlbumsRequest> 1761 1761 + for GetAlbumsSvc<T> { 1528 1762 type Response = super::GetAlbumsResponse; 1529 1529 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1763 1763 + type Future = BoxFuture< 1764 1764 + tonic::Response<Self::Response>, 1765 1765 + tonic::Status, 1766 1766 + >; 1530 1767 fn call( 1531 1768 &mut self, 1532 1769 request: tonic::Request<super::GetAlbumsRequest>, ··· 1563 1800 "/rockbox.v1alpha1.LibraryService/GetArtists" => { 1564 1801 #[allow(non_camel_case_types)] 1565 1802 struct GetArtistsSvc<T: LibraryService>(pub Arc<T>); 1566 1566 - impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistsRequest> for GetArtistsSvc<T> { 1803 1803 + impl< 1804 1804 + T: LibraryService, 1805 1805 + > tonic::server::UnaryService<super::GetArtistsRequest> 1806 1806 + for GetArtistsSvc<T> { 1567 1807 type Response = super::GetArtistsResponse; 1568 1568 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1808 1808 + type Future = BoxFuture< 1809 1809 + tonic::Response<Self::Response>, 1810 1810 + tonic::Status, 1811 1811 + >; 1569 1812 fn call( 1570 1813 &mut self, 1571 1814 request: tonic::Request<super::GetArtistsRequest>, ··· 1602 1845 "/rockbox.v1alpha1.LibraryService/GetTracks" => { 1603 1846 #[allow(non_camel_case_types)] 1604 1847 struct GetTracksSvc<T: LibraryService>(pub Arc<T>); 1605 1605 - impl<T: LibraryService> tonic::server::UnaryService<super::GetTracksRequest> for GetTracksSvc<T> { 1848 1848 + impl< 1849 1849 + T: LibraryService, 1850 1850 + > tonic::server::UnaryService<super::GetTracksRequest> 1851 1851 + for GetTracksSvc<T> { 1606 1852 type Response = super::GetTracksResponse; 1607 1607 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1853 1853 + type Future = BoxFuture< 1854 1854 + tonic::Response<Self::Response>, 1855 1855 + tonic::Status, 1856 1856 + >; 1608 1857 fn call( 1609 1858 &mut self, 1610 1859 request: tonic::Request<super::GetTracksRequest>, ··· 1641 1890 "/rockbox.v1alpha1.LibraryService/GetAlbum" => { 1642 1891 #[allow(non_camel_case_types)] 1643 1892 struct GetAlbumSvc<T: LibraryService>(pub Arc<T>); 1644 1644 - impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumRequest> for GetAlbumSvc<T> { 1893 1893 + impl< 1894 1894 + T: LibraryService, 1895 1895 + > tonic::server::UnaryService<super::GetAlbumRequest> 1896 1896 + for GetAlbumSvc<T> { 1645 1897 type Response = super::GetAlbumResponse; 1646 1646 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1898 1898 + type Future = BoxFuture< 1899 1899 + tonic::Response<Self::Response>, 1900 1900 + tonic::Status, 1901 1901 + >; 1647 1902 fn call( 1648 1903 &mut self, 1649 1904 request: tonic::Request<super::GetAlbumRequest>, ··· 1680 1935 "/rockbox.v1alpha1.LibraryService/GetArtist" => { 1681 1936 #[allow(non_camel_case_types)] 1682 1937 struct GetArtistSvc<T: LibraryService>(pub Arc<T>); 1683 1683 - impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistRequest> for GetArtistSvc<T> { 1938 1938 + impl< 1939 1939 + T: LibraryService, 1940 1940 + > tonic::server::UnaryService<super::GetArtistRequest> 1941 1941 + for GetArtistSvc<T> { 1684 1942 type Response = super::GetArtistResponse; 1685 1685 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1943 1943 + type Future = BoxFuture< 1944 1944 + tonic::Response<Self::Response>, 1945 1945 + tonic::Status, 1946 1946 + >; 1686 1947 fn call( 1687 1948 &mut self, 1688 1949 request: tonic::Request<super::GetArtistRequest>, ··· 1719 1980 "/rockbox.v1alpha1.LibraryService/GetTrack" => { 1720 1981 #[allow(non_camel_case_types)] 1721 1982 struct GetTrackSvc<T: LibraryService>(pub Arc<T>); 1722 1722 - impl<T: LibraryService> tonic::server::UnaryService<super::GetTrackRequest> for GetTrackSvc<T> { 1983 1983 + impl< 1984 1984 + T: LibraryService, 1985 1985 + > tonic::server::UnaryService<super::GetTrackRequest> 1986 1986 + for GetTrackSvc<T> { 1723 1987 type Response = super::GetTrackResponse; 1724 1724 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1988 1988 + type Future = BoxFuture< 1989 1989 + tonic::Response<Self::Response>, 1990 1990 + tonic::Status, 1991 1991 + >; 1725 1992 fn call( 1726 1993 &mut self, 1727 1994 request: tonic::Request<super::GetTrackRequest>, ··· 1758 2025 "/rockbox.v1alpha1.LibraryService/LikeTrack" => { 1759 2026 #[allow(non_camel_case_types)] 1760 2027 struct LikeTrackSvc<T: LibraryService>(pub Arc<T>); 1761 1761 - impl<T: LibraryService> tonic::server::UnaryService<super::LikeTrackRequest> for LikeTrackSvc<T> { 2028 2028 + impl< 2029 2029 + T: LibraryService, 2030 2030 + > tonic::server::UnaryService<super::LikeTrackRequest> 2031 2031 + for LikeTrackSvc<T> { 1762 2032 type Response = super::LikeTrackResponse; 1763 1763 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2033 2033 + type Future = BoxFuture< 2034 2034 + tonic::Response<Self::Response>, 2035 2035 + tonic::Status, 2036 2036 + >; 1764 2037 fn call( 1765 2038 &mut self, 1766 2039 request: tonic::Request<super::LikeTrackRequest>, ··· 1797 2070 "/rockbox.v1alpha1.LibraryService/UnlikeTrack" => { 1798 2071 #[allow(non_camel_case_types)] 1799 2072 struct UnlikeTrackSvc<T: LibraryService>(pub Arc<T>); 1800 1800 - impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeTrackRequest> 1801 1801 - for UnlikeTrackSvc<T> 1802 1802 - { 2073 2073 + impl< 2074 2074 + T: LibraryService, 2075 2075 + > tonic::server::UnaryService<super::UnlikeTrackRequest> 2076 2076 + for UnlikeTrackSvc<T> { 1803 2077 type Response = super::UnlikeTrackResponse; 1804 1804 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2078 2078 + type Future = BoxFuture< 2079 2079 + tonic::Response<Self::Response>, 2080 2080 + tonic::Status, 2081 2081 + >; 1805 2082 fn call( 1806 2083 &mut self, 1807 2084 request: tonic::Request<super::UnlikeTrackRequest>, ··· 1838 2115 "/rockbox.v1alpha1.LibraryService/LikeAlbum" => { 1839 2116 #[allow(non_camel_case_types)] 1840 2117 struct LikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1841 1841 - impl<T: LibraryService> tonic::server::UnaryService<super::LikeAlbumRequest> for LikeAlbumSvc<T> { 2118 2118 + impl< 2119 2119 + T: LibraryService, 2120 2120 + > tonic::server::UnaryService<super::LikeAlbumRequest> 2121 2121 + for LikeAlbumSvc<T> { 1842 2122 type Response = super::LikeAlbumResponse; 1843 1843 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2123 2123 + type Future = BoxFuture< 2124 2124 + tonic::Response<Self::Response>, 2125 2125 + tonic::Status, 2126 2126 + >; 1844 2127 fn call( 1845 2128 &mut self, 1846 2129 request: tonic::Request<super::LikeAlbumRequest>, ··· 1877 2160 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum" => { 1878 2161 #[allow(non_camel_case_types)] 1879 2162 struct UnlikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1880 1880 - impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeAlbumRequest> 1881 1881 - for UnlikeAlbumSvc<T> 1882 1882 - { 2163 2163 + impl< 2164 2164 + T: LibraryService, 2165 2165 + > tonic::server::UnaryService<super::UnlikeAlbumRequest> 2166 2166 + for UnlikeAlbumSvc<T> { 1883 2167 type Response = super::UnlikeAlbumResponse; 1884 1884 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2168 2168 + type Future = BoxFuture< 2169 2169 + tonic::Response<Self::Response>, 2170 2170 + tonic::Status, 2171 2171 + >; 1885 2172 fn call( 1886 2173 &mut self, 1887 2174 request: tonic::Request<super::UnlikeAlbumRequest>, ··· 1918 2205 "/rockbox.v1alpha1.LibraryService/GetLikedTracks" => { 1919 2206 #[allow(non_camel_case_types)] 1920 2207 struct GetLikedTracksSvc<T: LibraryService>(pub Arc<T>); 1921 1921 - impl<T: LibraryService> 1922 1922 - tonic::server::UnaryService<super::GetLikedTracksRequest> 1923 1923 - for GetLikedTracksSvc<T> 1924 1924 - { 2208 2208 + impl< 2209 2209 + T: LibraryService, 2210 2210 + > tonic::server::UnaryService<super::GetLikedTracksRequest> 2211 2211 + for GetLikedTracksSvc<T> { 1925 2212 type Response = super::GetLikedTracksResponse; 1926 1926 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2213 2213 + type Future = BoxFuture< 2214 2214 + tonic::Response<Self::Response>, 2215 2215 + tonic::Status, 2216 2216 + >; 1927 2217 fn call( 1928 2218 &mut self, 1929 2219 request: tonic::Request<super::GetLikedTracksRequest>, 1930 2220 ) -> Self::Future { 1931 2221 let inner = Arc::clone(&self.0); 1932 2222 let fut = async move { 1933 1933 - <T as LibraryService>::get_liked_tracks(&inner, request).await 2223 2223 + <T as LibraryService>::get_liked_tracks(&inner, request) 2224 2224 + .await 1934 2225 }; 1935 2226 Box::pin(fut) 1936 2227 } ··· 1960 2251 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums" => { 1961 2252 #[allow(non_camel_case_types)] 1962 2253 struct GetLikedAlbumsSvc<T: LibraryService>(pub Arc<T>); 1963 1963 - impl<T: LibraryService> 1964 1964 - tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1965 1965 - for GetLikedAlbumsSvc<T> 1966 1966 - { 2254 2254 + impl< 2255 2255 + T: LibraryService, 2256 2256 + > tonic::server::UnaryService<super::GetLikedAlbumsRequest> 2257 2257 + for GetLikedAlbumsSvc<T> { 1967 2258 type Response = super::GetLikedAlbumsResponse; 1968 1968 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2259 2259 + type Future = BoxFuture< 2260 2260 + tonic::Response<Self::Response>, 2261 2261 + tonic::Status, 2262 2262 + >; 1969 2263 fn call( 1970 2264 &mut self, 1971 2265 request: tonic::Request<super::GetLikedAlbumsRequest>, 1972 2266 ) -> Self::Future { 1973 2267 let inner = Arc::clone(&self.0); 1974 2268 let fut = async move { 1975 1975 - <T as LibraryService>::get_liked_albums(&inner, request).await 2269 2269 + <T as LibraryService>::get_liked_albums(&inner, request) 2270 2270 + .await 1976 2271 }; 1977 2272 Box::pin(fut) 1978 2273 } ··· 2002 2297 "/rockbox.v1alpha1.LibraryService/ScanLibrary" => { 2003 2298 #[allow(non_camel_case_types)] 2004 2299 struct ScanLibrarySvc<T: LibraryService>(pub Arc<T>); 2005 2005 - impl<T: LibraryService> tonic::server::UnaryService<super::ScanLibraryRequest> 2006 2006 - for ScanLibrarySvc<T> 2007 2007 - { 2300 2300 + impl< 2301 2301 + T: LibraryService, 2302 2302 + > tonic::server::UnaryService<super::ScanLibraryRequest> 2303 2303 + for ScanLibrarySvc<T> { 2008 2304 type Response = super::ScanLibraryResponse; 2009 2009 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2305 2305 + type Future = BoxFuture< 2306 2306 + tonic::Response<Self::Response>, 2307 2307 + tonic::Status, 2308 2308 + >; 2010 2309 fn call( 2011 2310 &mut self, 2012 2311 request: tonic::Request<super::ScanLibraryRequest>, ··· 2043 2342 "/rockbox.v1alpha1.LibraryService/Search" => { 2044 2343 #[allow(non_camel_case_types)] 2045 2344 struct SearchSvc<T: LibraryService>(pub Arc<T>); 2046 2046 - impl<T: LibraryService> tonic::server::UnaryService<super::SearchRequest> for SearchSvc<T> { 2345 2345 + impl< 2346 2346 + T: LibraryService, 2347 2347 + > tonic::server::UnaryService<super::SearchRequest> 2348 2348 + for SearchSvc<T> { 2047 2349 type Response = super::SearchResponse; 2048 2048 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 2350 2350 + type Future = BoxFuture< 2351 2351 + tonic::Response<Self::Response>, 2352 2352 + tonic::Status, 2353 2353 + >; 2049 2354 fn call( 2050 2355 &mut self, 2051 2356 request: tonic::Request<super::SearchRequest>, 2052 2357 ) -> Self::Future { 2053 2358 let inner = Arc::clone(&self.0); 2054 2054 - let fut = 2055 2055 - async move { <T as LibraryService>::search(&inner, request).await }; 2359 2359 + let fut = async move { 2360 2360 + <T as LibraryService>::search(&inner, request).await 2361 2361 + }; 2056 2362 Box::pin(fut) 2057 2363 } 2058 2364 } ··· 2078 2384 }; 2079 2385 Box::pin(fut) 2080 2386 } 2081 2081 - _ => Box::pin(async move { 2082 2082 - let mut response = http::Response::new(empty_body()); 2083 2083 - let headers = response.headers_mut(); 2084 2084 - headers.insert( 2085 2085 - tonic::Status::GRPC_STATUS, 2086 2086 - (tonic::Code::Unimplemented as i32).into(), 2087 2087 - ); 2088 2088 - headers.insert( 2089 2089 - http::header::CONTENT_TYPE, 2090 2090 - tonic::metadata::GRPC_CONTENT_TYPE, 2091 2091 - ); 2092 2092 - Ok(response) 2093 2093 - }), 2387 2387 + _ => { 2388 2388 + Box::pin(async move { 2389 2389 + let mut response = http::Response::new(empty_body()); 2390 2390 + let headers = response.headers_mut(); 2391 2391 + headers 2392 2392 + .insert( 2393 2393 + tonic::Status::GRPC_STATUS, 2394 2394 + (tonic::Code::Unimplemented as i32).into(), 2395 2395 + ); 2396 2396 + headers 2397 2397 + .insert( 2398 2398 + http::header::CONTENT_TYPE, 2399 2399 + tonic::metadata::GRPC_CONTENT_TYPE, 2400 2400 + ); 2401 2401 + Ok(response) 2402 2402 + }) 2403 2403 + } 2094 2404 } 2095 2405 } 2096 2406 } ··· 2119 2429 dead_code, 2120 2430 missing_docs, 2121 2431 clippy::wildcard_imports, 2122 2122 - clippy::let_unit_value 2432 2432 + clippy::let_unit_value, 2123 2433 )] 2124 2124 - use tonic::codegen::http::Uri; 2125 2434 use tonic::codegen::*; 2435 2435 + use tonic::codegen::http::Uri; 2126 2436 #[derive(Debug, Clone)] 2127 2437 pub struct MetadataServiceClient<T> { 2128 2438 inner: tonic::client::Grpc<T>, ··· 2166 2476 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 2167 2477 >, 2168 2478 >, 2169 2169 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 2170 2170 - Into<StdError> + std::marker::Send + std::marker::Sync, 2479 2479 + <T as tonic::codegen::Service< 2480 2480 + http::Request<tonic::body::BoxBody>, 2481 2481 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 2171 2482 { 2172 2483 MetadataServiceClient::new(InterceptedService::new(inner, interceptor)) 2173 2484 } ··· 2211 2522 dead_code, 2212 2523 missing_docs, 2213 2524 clippy::wildcard_imports, 2214 2214 - clippy::let_unit_value 2525 2525 + clippy::let_unit_value, 2215 2526 )] 2216 2527 use tonic::codegen::*; 2217 2528 /// Generated trait containing gRPC methods that should be implemented for use with MetadataServiceServer. ··· 2238 2549 max_encoding_message_size: None, 2239 2550 } 2240 2551 } 2241 2241 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 2552 2552 + pub fn with_interceptor<F>( 2553 2553 + inner: T, 2554 2554 + interceptor: F, 2555 2555 + ) -> InterceptedService<Self, F> 2242 2556 where 2243 2557 F: tonic::service::Interceptor, 2244 2558 { ··· 2290 2604 } 2291 2605 fn call(&mut self, req: http::Request<B>) -> Self::Future { 2292 2606 match req.uri().path() { 2293 2293 - _ => Box::pin(async move { 2294 2294 - let mut response = http::Response::new(empty_body()); 2295 2295 - let headers = response.headers_mut(); 2296 2296 - headers.insert( 2297 2297 - tonic::Status::GRPC_STATUS, 2298 2298 - (tonic::Code::Unimplemented as i32).into(), 2299 2299 - ); 2300 2300 - headers.insert( 2301 2301 - http::header::CONTENT_TYPE, 2302 2302 - tonic::metadata::GRPC_CONTENT_TYPE, 2303 2303 - ); 2304 2304 - Ok(response) 2305 2305 - }), 2607 2607 + _ => { 2608 2608 + Box::pin(async move { 2609 2609 + let mut response = http::Response::new(empty_body()); 2610 2610 + let headers = response.headers_mut(); 2611 2611 + headers 2612 2612 + .insert( 2613 2613 + tonic::Status::GRPC_STATUS, 2614 2614 + (tonic::Code::Unimplemented as i32).into(), 2615 2615 + ); 2616 2616 + headers 2617 2617 + .insert( 2618 2618 + http::header::CONTENT_TYPE, 2619 2619 + tonic::metadata::GRPC_CONTENT_TYPE, 2620 2620 + ); 2621 2621 + Ok(response) 2622 2622 + }) 2623 2623 + } 2306 2624 } 2307 2625 } 2308 2626 } ··· 2575 2893 dead_code, 2576 2894 missing_docs, 2577 2895 clippy::wildcard_imports, 2578 2578 - clippy::let_unit_value 2896 2896 + clippy::let_unit_value, 2579 2897 )] 2580 2580 - use tonic::codegen::http::Uri; 2581 2898 use tonic::codegen::*; 2899 2899 + use tonic::codegen::http::Uri; 2582 2900 #[derive(Debug, Clone)] 2583 2901 pub struct PlaybackServiceClient<T> { 2584 2902 inner: tonic::client::Grpc<T>, ··· 2622 2940 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 2623 2941 >, 2624 2942 >, 2625 2625 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 2626 2626 - Into<StdError> + std::marker::Send + std::marker::Sync, 2943 2943 + <T as tonic::codegen::Service< 2944 2944 + http::Request<tonic::body::BoxBody>, 2945 2945 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 2627 2946 { 2628 2947 PlaybackServiceClient::new(InterceptedService::new(inner, interceptor)) 2629 2948 } ··· 2662 2981 &mut self, 2663 2982 request: impl tonic::IntoRequest<super::PlayRequest>, 2664 2983 ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> { 2665 2665 - self.inner.ready().await.map_err(|e| { 2666 2666 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2667 2667 - })?; 2984 2984 + self.inner 2985 2985 + .ready() 2986 2986 + .await 2987 2987 + .map_err(|e| { 2988 2988 + tonic::Status::unknown( 2989 2989 + format!("Service was not ready: {}", e.into()), 2990 2990 + ) 2991 2991 + })?; 2668 2992 let codec = tonic::codec::ProstCodec::default(); 2669 2669 - let path = 2670 2670 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Play"); 2993 2993 + let path = http::uri::PathAndQuery::from_static( 2994 2994 + "/rockbox.v1alpha1.PlaybackService/Play", 2995 2995 + ); 2671 2996 let mut req = request.into_request(); 2672 2997 req.extensions_mut() 2673 2998 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Play")); ··· 2677 3002 &mut self, 2678 3003 request: impl tonic::IntoRequest<super::PauseRequest>, 2679 3004 ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> { 2680 2680 - self.inner.ready().await.map_err(|e| { 2681 2681 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2682 2682 - })?; 3005 3005 + self.inner 3006 3006 + .ready() 3007 3007 + .await 3008 3008 + .map_err(|e| { 3009 3009 + tonic::Status::unknown( 3010 3010 + format!("Service was not ready: {}", e.into()), 3011 3011 + ) 3012 3012 + })?; 2683 3013 let codec = tonic::codec::ProstCodec::default(); 2684 2684 - let path = 2685 2685 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Pause"); 3014 3014 + let path = http::uri::PathAndQuery::from_static( 3015 3015 + "/rockbox.v1alpha1.PlaybackService/Pause", 3016 3016 + ); 2686 3017 let mut req = request.into_request(); 2687 3018 req.extensions_mut() 2688 3019 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Pause")); ··· 2691 3022 pub async fn play_or_pause( 2692 3023 &mut self, 2693 3024 request: impl tonic::IntoRequest<super::PlayOrPauseRequest>, 2694 2694 - ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status> 2695 2695 - { 2696 2696 - self.inner.ready().await.map_err(|e| { 2697 2697 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2698 2698 - })?; 3025 3025 + ) -> std::result::Result< 3026 3026 + tonic::Response<super::PlayOrPauseResponse>, 3027 3027 + tonic::Status, 3028 3028 + > { 3029 3029 + self.inner 3030 3030 + .ready() 3031 3031 + .await 3032 3032 + .map_err(|e| { 3033 3033 + tonic::Status::unknown( 3034 3034 + format!("Service was not ready: {}", e.into()), 3035 3035 + ) 3036 3036 + })?; 2699 3037 let codec = tonic::codec::ProstCodec::default(); 2700 3038 let path = http::uri::PathAndQuery::from_static( 2701 3039 "/rockbox.v1alpha1.PlaybackService/PlayOrPause", 2702 3040 ); 2703 3041 let mut req = request.into_request(); 2704 2704 - req.extensions_mut().insert(GrpcMethod::new( 2705 2705 - "rockbox.v1alpha1.PlaybackService", 2706 2706 - "PlayOrPause", 2707 2707 - )); 3042 3042 + req.extensions_mut() 3043 3043 + .insert( 3044 3044 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayOrPause"), 3045 3045 + ); 2708 3046 self.inner.unary(req, path, codec).await 2709 3047 } 2710 3048 pub async fn resume( 2711 3049 &mut self, 2712 3050 request: impl tonic::IntoRequest<super::ResumeRequest>, 2713 3051 ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> { 2714 2714 - self.inner.ready().await.map_err(|e| { 2715 2715 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2716 2716 - })?; 3052 3052 + self.inner 3053 3053 + .ready() 3054 3054 + .await 3055 3055 + .map_err(|e| { 3056 3056 + tonic::Status::unknown( 3057 3057 + format!("Service was not ready: {}", e.into()), 3058 3058 + ) 3059 3059 + })?; 2717 3060 let codec = tonic::codec::ProstCodec::default(); 2718 2718 - let path = 2719 2719 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Resume"); 3061 3061 + let path = http::uri::PathAndQuery::from_static( 3062 3062 + "/rockbox.v1alpha1.PlaybackService/Resume", 3063 3063 + ); 2720 3064 let mut req = request.into_request(); 2721 2721 - req.extensions_mut().insert(GrpcMethod::new( 2722 2722 - "rockbox.v1alpha1.PlaybackService", 2723 2723 - "Resume", 2724 2724 - )); 3065 3065 + req.extensions_mut() 3066 3066 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Resume")); 2725 3067 self.inner.unary(req, path, codec).await 2726 3068 } 2727 3069 pub async fn next( 2728 3070 &mut self, 2729 3071 request: impl tonic::IntoRequest<super::NextRequest>, 2730 3072 ) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status> { 2731 2731 - self.inner.ready().await.map_err(|e| { 2732 2732 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2733 2733 - })?; 3073 3073 + self.inner 3074 3074 + .ready() 3075 3075 + .await 3076 3076 + .map_err(|e| { 3077 3077 + tonic::Status::unknown( 3078 3078 + format!("Service was not ready: {}", e.into()), 3079 3079 + ) 3080 3080 + })?; 2734 3081 let codec = tonic::codec::ProstCodec::default(); 2735 2735 - let path = 2736 2736 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Next"); 3082 3082 + let path = http::uri::PathAndQuery::from_static( 3083 3083 + "/rockbox.v1alpha1.PlaybackService/Next", 3084 3084 + ); 2737 3085 let mut req = request.into_request(); 2738 3086 req.extensions_mut() 2739 3087 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Next")); ··· 2742 3090 pub async fn previous( 2743 3091 &mut self, 2744 3092 request: impl tonic::IntoRequest<super::PreviousRequest>, 2745 2745 - ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status> { 2746 2746 - self.inner.ready().await.map_err(|e| { 2747 2747 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2748 2748 - })?; 3093 3093 + ) -> std::result::Result< 3094 3094 + tonic::Response<super::PreviousResponse>, 3095 3095 + tonic::Status, 3096 3096 + > { 3097 3097 + self.inner 3098 3098 + .ready() 3099 3099 + .await 3100 3100 + .map_err(|e| { 3101 3101 + tonic::Status::unknown( 3102 3102 + format!("Service was not ready: {}", e.into()), 3103 3103 + ) 3104 3104 + })?; 2749 3105 let codec = tonic::codec::ProstCodec::default(); 2750 2750 - let path = 2751 2751 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Previous"); 3106 3106 + let path = http::uri::PathAndQuery::from_static( 3107 3107 + "/rockbox.v1alpha1.PlaybackService/Previous", 3108 3108 + ); 2752 3109 let mut req = request.into_request(); 2753 2753 - req.extensions_mut().insert(GrpcMethod::new( 2754 2754 - "rockbox.v1alpha1.PlaybackService", 2755 2755 - "Previous", 2756 2756 - )); 3110 3110 + req.extensions_mut() 3111 3111 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Previous")); 2757 3112 self.inner.unary(req, path, codec).await 2758 3113 } 2759 3114 pub async fn fast_forward_rewind( 2760 3115 &mut self, 2761 3116 request: impl tonic::IntoRequest<super::FastForwardRewindRequest>, 2762 2762 - ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status> 2763 2763 - { 2764 2764 - self.inner.ready().await.map_err(|e| { 2765 2765 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2766 2766 - })?; 3117 3117 + ) -> std::result::Result< 3118 3118 + tonic::Response<super::FastForwardRewindResponse>, 3119 3119 + tonic::Status, 3120 3120 + > { 3121 3121 + self.inner 3122 3122 + .ready() 3123 3123 + .await 3124 3124 + .map_err(|e| { 3125 3125 + tonic::Status::unknown( 3126 3126 + format!("Service was not ready: {}", e.into()), 3127 3127 + ) 3128 3128 + })?; 2767 3129 let codec = tonic::codec::ProstCodec::default(); 2768 3130 let path = http::uri::PathAndQuery::from_static( 2769 3131 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind", 2770 3132 ); 2771 3133 let mut req = request.into_request(); 2772 2772 - req.extensions_mut().insert(GrpcMethod::new( 2773 2773 - "rockbox.v1alpha1.PlaybackService", 2774 2774 - "FastForwardRewind", 2775 2775 - )); 3134 3134 + req.extensions_mut() 3135 3135 + .insert( 3136 3136 + GrpcMethod::new( 3137 3137 + "rockbox.v1alpha1.PlaybackService", 3138 3138 + "FastForwardRewind", 3139 3139 + ), 3140 3140 + ); 2776 3141 self.inner.unary(req, path, codec).await 2777 3142 } 2778 3143 pub async fn status( 2779 3144 &mut self, 2780 3145 request: impl tonic::IntoRequest<super::StatusRequest>, 2781 3146 ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> { 2782 2782 - self.inner.ready().await.map_err(|e| { 2783 2783 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2784 2784 - })?; 3147 3147 + self.inner 3148 3148 + .ready() 3149 3149 + .await 3150 3150 + .map_err(|e| { 3151 3151 + tonic::Status::unknown( 3152 3152 + format!("Service was not ready: {}", e.into()), 3153 3153 + ) 3154 3154 + })?; 2785 3155 let codec = tonic::codec::ProstCodec::default(); 2786 2786 - let path = 2787 2787 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Status"); 3156 3156 + let path = http::uri::PathAndQuery::from_static( 3157 3157 + "/rockbox.v1alpha1.PlaybackService/Status", 3158 3158 + ); 2788 3159 let mut req = request.into_request(); 2789 2789 - req.extensions_mut().insert(GrpcMethod::new( 2790 2790 - "rockbox.v1alpha1.PlaybackService", 2791 2791 - "Status", 2792 2792 - )); 3160 3160 + req.extensions_mut() 3161 3161 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Status")); 2793 3162 self.inner.unary(req, path, codec).await 2794 3163 } 2795 3164 pub async fn current_track( 2796 3165 &mut self, 2797 3166 request: impl tonic::IntoRequest<super::CurrentTrackRequest>, 2798 2798 - ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status> 2799 2799 - { 2800 2800 - self.inner.ready().await.map_err(|e| { 2801 2801 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2802 2802 - })?; 3167 3167 + ) -> std::result::Result< 3168 3168 + tonic::Response<super::CurrentTrackResponse>, 3169 3169 + tonic::Status, 3170 3170 + > { 3171 3171 + self.inner 3172 3172 + .ready() 3173 3173 + .await 3174 3174 + .map_err(|e| { 3175 3175 + tonic::Status::unknown( 3176 3176 + format!("Service was not ready: {}", e.into()), 3177 3177 + ) 3178 3178 + })?; 2803 3179 let codec = tonic::codec::ProstCodec::default(); 2804 3180 let path = http::uri::PathAndQuery::from_static( 2805 3181 "/rockbox.v1alpha1.PlaybackService/CurrentTrack", 2806 3182 ); 2807 3183 let mut req = request.into_request(); 2808 2808 - req.extensions_mut().insert(GrpcMethod::new( 2809 2809 - "rockbox.v1alpha1.PlaybackService", 2810 2810 - "CurrentTrack", 2811 2811 - )); 3184 3184 + req.extensions_mut() 3185 3185 + .insert( 3186 3186 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "CurrentTrack"), 3187 3187 + ); 2812 3188 self.inner.unary(req, path, codec).await 2813 3189 } 2814 3190 pub async fn next_track( 2815 3191 &mut self, 2816 3192 request: impl tonic::IntoRequest<super::NextTrackRequest>, 2817 2817 - ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status> { 2818 2818 - self.inner.ready().await.map_err(|e| { 2819 2819 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2820 2820 - })?; 3193 3193 + ) -> std::result::Result< 3194 3194 + tonic::Response<super::NextTrackResponse>, 3195 3195 + tonic::Status, 3196 3196 + > { 3197 3197 + self.inner 3198 3198 + .ready() 3199 3199 + .await 3200 3200 + .map_err(|e| { 3201 3201 + tonic::Status::unknown( 3202 3202 + format!("Service was not ready: {}", e.into()), 3203 3203 + ) 3204 3204 + })?; 2821 3205 let codec = tonic::codec::ProstCodec::default(); 2822 2822 - let path = 2823 2823 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/NextTrack"); 3206 3206 + let path = http::uri::PathAndQuery::from_static( 3207 3207 + "/rockbox.v1alpha1.PlaybackService/NextTrack", 3208 3208 + ); 2824 3209 let mut req = request.into_request(); 2825 2825 - req.extensions_mut().insert(GrpcMethod::new( 2826 2826 - "rockbox.v1alpha1.PlaybackService", 2827 2827 - "NextTrack", 2828 2828 - )); 3210 3210 + req.extensions_mut() 3211 3211 + .insert( 3212 3212 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "NextTrack"), 3213 3213 + ); 2829 3214 self.inner.unary(req, path, codec).await 2830 3215 } 2831 3216 pub async fn flush_and_reload_tracks( 2832 3217 &mut self, 2833 3218 request: impl tonic::IntoRequest<super::FlushAndReloadTracksRequest>, 2834 2834 - ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status> 2835 2835 - { 2836 2836 - self.inner.ready().await.map_err(|e| { 2837 2837 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2838 2838 - })?; 3219 3219 + ) -> std::result::Result< 3220 3220 + tonic::Response<super::FlushAndReloadTracksResponse>, 3221 3221 + tonic::Status, 3222 3222 + > { 3223 3223 + self.inner 3224 3224 + .ready() 3225 3225 + .await 3226 3226 + .map_err(|e| { 3227 3227 + tonic::Status::unknown( 3228 3228 + format!("Service was not ready: {}", e.into()), 3229 3229 + ) 3230 3230 + })?; 2839 3231 let codec = tonic::codec::ProstCodec::default(); 2840 3232 let path = http::uri::PathAndQuery::from_static( 2841 3233 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks", 2842 3234 ); 2843 3235 let mut req = request.into_request(); 2844 2844 - req.extensions_mut().insert(GrpcMethod::new( 2845 2845 - "rockbox.v1alpha1.PlaybackService", 2846 2846 - "FlushAndReloadTracks", 2847 2847 - )); 3236 3236 + req.extensions_mut() 3237 3237 + .insert( 3238 3238 + GrpcMethod::new( 3239 3239 + "rockbox.v1alpha1.PlaybackService", 3240 3240 + "FlushAndReloadTracks", 3241 3241 + ), 3242 3242 + ); 2848 3243 self.inner.unary(req, path, codec).await 2849 3244 } 2850 3245 pub async fn get_file_position( 2851 3246 &mut self, 2852 3247 request: impl tonic::IntoRequest<super::GetFilePositionRequest>, 2853 2853 - ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status> 2854 2854 - { 2855 2855 - self.inner.ready().await.map_err(|e| { 2856 2856 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2857 2857 - })?; 3248 3248 + ) -> std::result::Result< 3249 3249 + tonic::Response<super::GetFilePositionResponse>, 3250 3250 + tonic::Status, 3251 3251 + > { 3252 3252 + self.inner 3253 3253 + .ready() 3254 3254 + .await 3255 3255 + .map_err(|e| { 3256 3256 + tonic::Status::unknown( 3257 3257 + format!("Service was not ready: {}", e.into()), 3258 3258 + ) 3259 3259 + })?; 2858 3260 let codec = tonic::codec::ProstCodec::default(); 2859 3261 let path = http::uri::PathAndQuery::from_static( 2860 3262 "/rockbox.v1alpha1.PlaybackService/GetFilePosition", 2861 3263 ); 2862 3264 let mut req = request.into_request(); 2863 2863 - req.extensions_mut().insert(GrpcMethod::new( 2864 2864 - "rockbox.v1alpha1.PlaybackService", 2865 2865 - "GetFilePosition", 2866 2866 - )); 3265 3265 + req.extensions_mut() 3266 3266 + .insert( 3267 3267 + GrpcMethod::new( 3268 3268 + "rockbox.v1alpha1.PlaybackService", 3269 3269 + "GetFilePosition", 3270 3270 + ), 3271 3271 + ); 2867 3272 self.inner.unary(req, path, codec).await 2868 3273 } 2869 3274 pub async fn hard_stop( 2870 3275 &mut self, 2871 3276 request: impl tonic::IntoRequest<super::HardStopRequest>, 2872 2872 - ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status> { 2873 2873 - self.inner.ready().await.map_err(|e| { 2874 2874 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2875 2875 - })?; 3277 3277 + ) -> std::result::Result< 3278 3278 + tonic::Response<super::HardStopResponse>, 3279 3279 + tonic::Status, 3280 3280 + > { 3281 3281 + self.inner 3282 3282 + .ready() 3283 3283 + .await 3284 3284 + .map_err(|e| { 3285 3285 + tonic::Status::unknown( 3286 3286 + format!("Service was not ready: {}", e.into()), 3287 3287 + ) 3288 3288 + })?; 2876 3289 let codec = tonic::codec::ProstCodec::default(); 2877 2877 - let path = 2878 2878 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/HardStop"); 3290 3290 + let path = http::uri::PathAndQuery::from_static( 3291 3291 + "/rockbox.v1alpha1.PlaybackService/HardStop", 3292 3292 + ); 2879 3293 let mut req = request.into_request(); 2880 2880 - req.extensions_mut().insert(GrpcMethod::new( 2881 2881 - "rockbox.v1alpha1.PlaybackService", 2882 2882 - "HardStop", 2883 2883 - )); 3294 3294 + req.extensions_mut() 3295 3295 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "HardStop")); 2884 3296 self.inner.unary(req, path, codec).await 2885 3297 } 2886 3298 pub async fn play_album( 2887 3299 &mut self, 2888 3300 request: impl tonic::IntoRequest<super::PlayAlbumRequest>, 2889 2889 - ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status> { 2890 2890 - self.inner.ready().await.map_err(|e| { 2891 2891 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2892 2892 - })?; 3301 3301 + ) -> std::result::Result< 3302 3302 + tonic::Response<super::PlayAlbumResponse>, 3303 3303 + tonic::Status, 3304 3304 + > { 3305 3305 + self.inner 3306 3306 + .ready() 3307 3307 + .await 3308 3308 + .map_err(|e| { 3309 3309 + tonic::Status::unknown( 3310 3310 + format!("Service was not ready: {}", e.into()), 3311 3311 + ) 3312 3312 + })?; 2893 3313 let codec = tonic::codec::ProstCodec::default(); 2894 2894 - let path = 2895 2895 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayAlbum"); 3314 3314 + let path = http::uri::PathAndQuery::from_static( 3315 3315 + "/rockbox.v1alpha1.PlaybackService/PlayAlbum", 3316 3316 + ); 2896 3317 let mut req = request.into_request(); 2897 2897 - req.extensions_mut().insert(GrpcMethod::new( 2898 2898 - "rockbox.v1alpha1.PlaybackService", 2899 2899 - "PlayAlbum", 2900 2900 - )); 3318 3318 + req.extensions_mut() 3319 3319 + .insert( 3320 3320 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAlbum"), 3321 3321 + ); 2901 3322 self.inner.unary(req, path, codec).await 2902 3323 } 2903 3324 pub async fn play_artist_tracks( 2904 3325 &mut self, 2905 3326 request: impl tonic::IntoRequest<super::PlayArtistTracksRequest>, 2906 2906 - ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status> 2907 2907 - { 2908 2908 - self.inner.ready().await.map_err(|e| { 2909 2909 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2910 2910 - })?; 3327 3327 + ) -> std::result::Result< 3328 3328 + tonic::Response<super::PlayArtistTracksResponse>, 3329 3329 + tonic::Status, 3330 3330 + > { 3331 3331 + self.inner 3332 3332 + .ready() 3333 3333 + .await 3334 3334 + .map_err(|e| { 3335 3335 + tonic::Status::unknown( 3336 3336 + format!("Service was not ready: {}", e.into()), 3337 3337 + ) 3338 3338 + })?; 2911 3339 let codec = tonic::codec::ProstCodec::default(); 2912 3340 let path = http::uri::PathAndQuery::from_static( 2913 3341 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks", 2914 3342 ); 2915 3343 let mut req = request.into_request(); 2916 2916 - req.extensions_mut().insert(GrpcMethod::new( 2917 2917 - "rockbox.v1alpha1.PlaybackService", 2918 2918 - "PlayArtistTracks", 2919 2919 - )); 3344 3344 + req.extensions_mut() 3345 3345 + .insert( 3346 3346 + GrpcMethod::new( 3347 3347 + "rockbox.v1alpha1.PlaybackService", 3348 3348 + "PlayArtistTracks", 3349 3349 + ), 3350 3350 + ); 2920 3351 self.inner.unary(req, path, codec).await 2921 3352 } 2922 3353 pub async fn play_playlist( 2923 3354 &mut self, 2924 3355 request: impl tonic::IntoRequest<super::PlayPlaylistRequest>, 2925 2925 - ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status> 2926 2926 - { 2927 2927 - self.inner.ready().await.map_err(|e| { 2928 2928 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2929 2929 - })?; 3356 3356 + ) -> std::result::Result< 3357 3357 + tonic::Response<super::PlayPlaylistResponse>, 3358 3358 + tonic::Status, 3359 3359 + > { 3360 3360 + self.inner 3361 3361 + .ready() 3362 3362 + .await 3363 3363 + .map_err(|e| { 3364 3364 + tonic::Status::unknown( 3365 3365 + format!("Service was not ready: {}", e.into()), 3366 3366 + ) 3367 3367 + })?; 2930 3368 let codec = tonic::codec::ProstCodec::default(); 2931 3369 let path = http::uri::PathAndQuery::from_static( 2932 3370 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist", 2933 3371 ); 2934 3372 let mut req = request.into_request(); 2935 2935 - req.extensions_mut().insert(GrpcMethod::new( 2936 2936 - "rockbox.v1alpha1.PlaybackService", 2937 2937 - "PlayPlaylist", 2938 2938 - )); 3373 3373 + req.extensions_mut() 3374 3374 + .insert( 3375 3375 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayPlaylist"), 3376 3376 + ); 2939 3377 self.inner.unary(req, path, codec).await 2940 3378 } 2941 3379 pub async fn play_directory( 2942 3380 &mut self, 2943 3381 request: impl tonic::IntoRequest<super::PlayDirectoryRequest>, 2944 2944 - ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status> 2945 2945 - { 2946 2946 - self.inner.ready().await.map_err(|e| { 2947 2947 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2948 2948 - })?; 3382 3382 + ) -> std::result::Result< 3383 3383 + tonic::Response<super::PlayDirectoryResponse>, 3384 3384 + tonic::Status, 3385 3385 + > { 3386 3386 + self.inner 3387 3387 + .ready() 3388 3388 + .await 3389 3389 + .map_err(|e| { 3390 3390 + tonic::Status::unknown( 3391 3391 + format!("Service was not ready: {}", e.into()), 3392 3392 + ) 3393 3393 + })?; 2949 3394 let codec = tonic::codec::ProstCodec::default(); 2950 3395 let path = http::uri::PathAndQuery::from_static( 2951 3396 "/rockbox.v1alpha1.PlaybackService/PlayDirectory", 2952 3397 ); 2953 3398 let mut req = request.into_request(); 2954 2954 - req.extensions_mut().insert(GrpcMethod::new( 2955 2955 - "rockbox.v1alpha1.PlaybackService", 2956 2956 - "PlayDirectory", 2957 2957 - )); 3399 3399 + req.extensions_mut() 3400 3400 + .insert( 3401 3401 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayDirectory"), 3402 3402 + ); 2958 3403 self.inner.unary(req, path, codec).await 2959 3404 } 2960 3405 pub async fn play_track( 2961 3406 &mut self, 2962 3407 request: impl tonic::IntoRequest<super::PlayTrackRequest>, 2963 2963 - ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status> { 2964 2964 - self.inner.ready().await.map_err(|e| { 2965 2965 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2966 2966 - })?; 3408 3408 + ) -> std::result::Result< 3409 3409 + tonic::Response<super::PlayTrackResponse>, 3410 3410 + tonic::Status, 3411 3411 + > { 3412 3412 + self.inner 3413 3413 + .ready() 3414 3414 + .await 3415 3415 + .map_err(|e| { 3416 3416 + tonic::Status::unknown( 3417 3417 + format!("Service was not ready: {}", e.into()), 3418 3418 + ) 3419 3419 + })?; 2967 3420 let codec = tonic::codec::ProstCodec::default(); 2968 2968 - let path = 2969 2969 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayTrack"); 3421 3421 + let path = http::uri::PathAndQuery::from_static( 3422 3422 + "/rockbox.v1alpha1.PlaybackService/PlayTrack", 3423 3423 + ); 2970 3424 let mut req = request.into_request(); 2971 2971 - req.extensions_mut().insert(GrpcMethod::new( 2972 2972 - "rockbox.v1alpha1.PlaybackService", 2973 2973 - "PlayTrack", 2974 2974 - )); 3425 3425 + req.extensions_mut() 3426 3426 + .insert( 3427 3427 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayTrack"), 3428 3428 + ); 2975 3429 self.inner.unary(req, path, codec).await 2976 3430 } 2977 3431 pub async fn play_liked_tracks( 2978 3432 &mut self, 2979 3433 request: impl tonic::IntoRequest<super::PlayLikedTracksRequest>, 2980 2980 - ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status> 2981 2981 - { 2982 2982 - self.inner.ready().await.map_err(|e| { 2983 2983 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2984 2984 - })?; 3434 3434 + ) -> std::result::Result< 3435 3435 + tonic::Response<super::PlayLikedTracksResponse>, 3436 3436 + tonic::Status, 3437 3437 + > { 3438 3438 + self.inner 3439 3439 + .ready() 3440 3440 + .await 3441 3441 + .map_err(|e| { 3442 3442 + tonic::Status::unknown( 3443 3443 + format!("Service was not ready: {}", e.into()), 3444 3444 + ) 3445 3445 + })?; 2985 3446 let codec = tonic::codec::ProstCodec::default(); 2986 3447 let path = http::uri::PathAndQuery::from_static( 2987 3448 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks", 2988 3449 ); 2989 3450 let mut req = request.into_request(); 2990 2990 - req.extensions_mut().insert(GrpcMethod::new( 2991 2991 - "rockbox.v1alpha1.PlaybackService", 2992 2992 - "PlayLikedTracks", 2993 2993 - )); 3451 3451 + req.extensions_mut() 3452 3452 + .insert( 3453 3453 + GrpcMethod::new( 3454 3454 + "rockbox.v1alpha1.PlaybackService", 3455 3455 + "PlayLikedTracks", 3456 3456 + ), 3457 3457 + ); 2994 3458 self.inner.unary(req, path, codec).await 2995 3459 } 2996 3460 pub async fn play_all_tracks( 2997 3461 &mut self, 2998 3462 request: impl tonic::IntoRequest<super::PlayAllTracksRequest>, 2999 2999 - ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status> 3000 3000 - { 3001 3001 - self.inner.ready().await.map_err(|e| { 3002 3002 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3003 3003 - })?; 3463 3463 + ) -> std::result::Result< 3464 3464 + tonic::Response<super::PlayAllTracksResponse>, 3465 3465 + tonic::Status, 3466 3466 + > { 3467 3467 + self.inner 3468 3468 + .ready() 3469 3469 + .await 3470 3470 + .map_err(|e| { 3471 3471 + tonic::Status::unknown( 3472 3472 + format!("Service was not ready: {}", e.into()), 3473 3473 + ) 3474 3474 + })?; 3004 3475 let codec = tonic::codec::ProstCodec::default(); 3005 3476 let path = http::uri::PathAndQuery::from_static( 3006 3477 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks", 3007 3478 ); 3008 3479 let mut req = request.into_request(); 3009 3009 - req.extensions_mut().insert(GrpcMethod::new( 3010 3010 - "rockbox.v1alpha1.PlaybackService", 3011 3011 - "PlayAllTracks", 3012 3012 - )); 3480 3480 + req.extensions_mut() 3481 3481 + .insert( 3482 3482 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAllTracks"), 3483 3483 + ); 3013 3484 self.inner.unary(req, path, codec).await 3014 3485 } 3015 3486 pub async fn stream_current_track( ··· 3019 3490 tonic::Response<tonic::codec::Streaming<super::CurrentTrackResponse>>, 3020 3491 tonic::Status, 3021 3492 > { 3022 3022 - self.inner.ready().await.map_err(|e| { 3023 3023 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3024 3024 - })?; 3493 3493 + self.inner 3494 3494 + .ready() 3495 3495 + .await 3496 3496 + .map_err(|e| { 3497 3497 + tonic::Status::unknown( 3498 3498 + format!("Service was not ready: {}", e.into()), 3499 3499 + ) 3500 3500 + })?; 3025 3501 let codec = tonic::codec::ProstCodec::default(); 3026 3502 let path = http::uri::PathAndQuery::from_static( 3027 3503 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack", 3028 3504 ); 3029 3505 let mut req = request.into_request(); 3030 3030 - req.extensions_mut().insert(GrpcMethod::new( 3031 3031 - "rockbox.v1alpha1.PlaybackService", 3032 3032 - "StreamCurrentTrack", 3033 3033 - )); 3506 3506 + req.extensions_mut() 3507 3507 + .insert( 3508 3508 + GrpcMethod::new( 3509 3509 + "rockbox.v1alpha1.PlaybackService", 3510 3510 + "StreamCurrentTrack", 3511 3511 + ), 3512 3512 + ); 3034 3513 self.inner.server_streaming(req, path, codec).await 3035 3514 } 3036 3515 pub async fn stream_status( ··· 3040 3519 tonic::Response<tonic::codec::Streaming<super::StatusResponse>>, 3041 3520 tonic::Status, 3042 3521 > { 3043 3043 - self.inner.ready().await.map_err(|e| { 3044 3044 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3045 3045 - })?; 3522 3522 + self.inner 3523 3523 + .ready() 3524 3524 + .await 3525 3525 + .map_err(|e| { 3526 3526 + tonic::Status::unknown( 3527 3527 + format!("Service was not ready: {}", e.into()), 3528 3528 + ) 3529 3529 + })?; 3046 3530 let codec = tonic::codec::ProstCodec::default(); 3047 3531 let path = http::uri::PathAndQuery::from_static( 3048 3532 "/rockbox.v1alpha1.PlaybackService/StreamStatus", 3049 3533 ); 3050 3534 let mut req = request.into_request(); 3051 3051 - req.extensions_mut().insert(GrpcMethod::new( 3052 3052 - "rockbox.v1alpha1.PlaybackService", 3053 3053 - "StreamStatus", 3054 3054 - )); 3535 3535 + req.extensions_mut() 3536 3536 + .insert( 3537 3537 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamStatus"), 3538 3538 + ); 3055 3539 self.inner.server_streaming(req, path, codec).await 3056 3540 } 3057 3541 pub async fn stream_playlist( ··· 3061 3545 tonic::Response<tonic::codec::Streaming<super::PlaylistResponse>>, 3062 3546 tonic::Status, 3063 3547 > { 3064 3064 - self.inner.ready().await.map_err(|e| { 3065 3065 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3066 3066 - })?; 3548 3548 + self.inner 3549 3549 + .ready() 3550 3550 + .await 3551 3551 + .map_err(|e| { 3552 3552 + tonic::Status::unknown( 3553 3553 + format!("Service was not ready: {}", e.into()), 3554 3554 + ) 3555 3555 + })?; 3067 3556 let codec = tonic::codec::ProstCodec::default(); 3068 3557 let path = http::uri::PathAndQuery::from_static( 3069 3558 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist", 3070 3559 ); 3071 3560 let mut req = request.into_request(); 3072 3072 - req.extensions_mut().insert(GrpcMethod::new( 3073 3073 - "rockbox.v1alpha1.PlaybackService", 3074 3074 - "StreamPlaylist", 3075 3075 - )); 3561 3561 + req.extensions_mut() 3562 3562 + .insert( 3563 3563 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamPlaylist"), 3564 3564 + ); 3076 3565 self.inner.server_streaming(req, path, codec).await 3077 3566 } 3078 3567 } ··· 3084 3573 dead_code, 3085 3574 missing_docs, 3086 3575 clippy::wildcard_imports, 3087 3087 - clippy::let_unit_value 3576 3576 + clippy::let_unit_value, 3088 3577 )] 3089 3578 use tonic::codegen::*; 3090 3579 /// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer. ··· 3101 3590 async fn play_or_pause( 3102 3591 &self, 3103 3592 request: tonic::Request<super::PlayOrPauseRequest>, 3104 3104 - ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status>; 3593 3593 + ) -> std::result::Result< 3594 3594 + tonic::Response<super::PlayOrPauseResponse>, 3595 3595 + tonic::Status, 3596 3596 + >; 3105 3597 async fn resume( 3106 3598 &self, 3107 3599 request: tonic::Request<super::ResumeRequest>, ··· 3113 3605 async fn previous( 3114 3606 &self, 3115 3607 request: tonic::Request<super::PreviousRequest>, 3116 3116 - ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status>; 3608 3608 + ) -> std::result::Result< 3609 3609 + tonic::Response<super::PreviousResponse>, 3610 3610 + tonic::Status, 3611 3611 + >; 3117 3612 async fn fast_forward_rewind( 3118 3613 &self, 3119 3614 request: tonic::Request<super::FastForwardRewindRequest>, 3120 3120 - ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>; 3615 3615 + ) -> std::result::Result< 3616 3616 + tonic::Response<super::FastForwardRewindResponse>, 3617 3617 + tonic::Status, 3618 3618 + >; 3121 3619 async fn status( 3122 3620 &self, 3123 3621 request: tonic::Request<super::StatusRequest>, ··· 3125 3623 async fn current_track( 3126 3624 &self, 3127 3625 request: tonic::Request<super::CurrentTrackRequest>, 3128 3128 - ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status>; 3626 3626 + ) -> std::result::Result< 3627 3627 + tonic::Response<super::CurrentTrackResponse>, 3628 3628 + tonic::Status, 3629 3629 + >; 3129 3630 async fn next_track( 3130 3631 &self, 3131 3632 request: tonic::Request<super::NextTrackRequest>, 3132 3132 - ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status>; 3633 3633 + ) -> std::result::Result< 3634 3634 + tonic::Response<super::NextTrackResponse>, 3635 3635 + tonic::Status, 3636 3636 + >; 3133 3637 async fn flush_and_reload_tracks( 3134 3638 &self, 3135 3639 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3136 3136 - ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status>; 3640 3640 + ) -> std::result::Result< 3641 3641 + tonic::Response<super::FlushAndReloadTracksResponse>, 3642 3642 + tonic::Status, 3643 3643 + >; 3137 3644 async fn get_file_position( 3138 3645 &self, 3139 3646 request: tonic::Request<super::GetFilePositionRequest>, 3140 3140 - ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status>; 3647 3647 + ) -> std::result::Result< 3648 3648 + tonic::Response<super::GetFilePositionResponse>, 3649 3649 + tonic::Status, 3650 3650 + >; 3141 3651 async fn hard_stop( 3142 3652 &self, 3143 3653 request: tonic::Request<super::HardStopRequest>, 3144 3144 - ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status>; 3654 3654 + ) -> std::result::Result< 3655 3655 + tonic::Response<super::HardStopResponse>, 3656 3656 + tonic::Status, 3657 3657 + >; 3145 3658 async fn play_album( 3146 3659 &self, 3147 3660 request: tonic::Request<super::PlayAlbumRequest>, 3148 3148 - ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status>; 3661 3661 + ) -> std::result::Result< 3662 3662 + tonic::Response<super::PlayAlbumResponse>, 3663 3663 + tonic::Status, 3664 3664 + >; 3149 3665 async fn play_artist_tracks( 3150 3666 &self, 3151 3667 request: tonic::Request<super::PlayArtistTracksRequest>, 3152 3152 - ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status>; 3668 3668 + ) -> std::result::Result< 3669 3669 + tonic::Response<super::PlayArtistTracksResponse>, 3670 3670 + tonic::Status, 3671 3671 + >; 3153 3672 async fn play_playlist( 3154 3673 &self, 3155 3674 request: tonic::Request<super::PlayPlaylistRequest>, 3156 3156 - ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status>; 3675 3675 + ) -> std::result::Result< 3676 3676 + tonic::Response<super::PlayPlaylistResponse>, 3677 3677 + tonic::Status, 3678 3678 + >; 3157 3679 async fn play_directory( 3158 3680 &self, 3159 3681 request: tonic::Request<super::PlayDirectoryRequest>, 3160 3160 - ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>; 3682 3682 + ) -> std::result::Result< 3683 3683 + tonic::Response<super::PlayDirectoryResponse>, 3684 3684 + tonic::Status, 3685 3685 + >; 3161 3686 async fn play_track( 3162 3687 &self, 3163 3688 request: tonic::Request<super::PlayTrackRequest>, 3164 3164 - ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status>; 3689 3689 + ) -> std::result::Result< 3690 3690 + tonic::Response<super::PlayTrackResponse>, 3691 3691 + tonic::Status, 3692 3692 + >; 3165 3693 async fn play_liked_tracks( 3166 3694 &self, 3167 3695 request: tonic::Request<super::PlayLikedTracksRequest>, 3168 3168 - ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status>; 3696 3696 + ) -> std::result::Result< 3697 3697 + tonic::Response<super::PlayLikedTracksResponse>, 3698 3698 + tonic::Status, 3699 3699 + >; 3169 3700 async fn play_all_tracks( 3170 3701 &self, 3171 3702 request: tonic::Request<super::PlayAllTracksRequest>, 3172 3172 - ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>; 3703 3703 + ) -> std::result::Result< 3704 3704 + tonic::Response<super::PlayAllTracksResponse>, 3705 3705 + tonic::Status, 3706 3706 + >; 3173 3707 /// Server streaming response type for the StreamCurrentTrack method. 3174 3708 type StreamCurrentTrackStream: tonic::codegen::tokio_stream::Stream< 3175 3709 Item = std::result::Result<super::CurrentTrackResponse, tonic::Status>, 3176 3176 - > + std::marker::Send 3710 3710 + > 3711 3711 + + std::marker::Send 3177 3712 + 'static; 3178 3713 async fn stream_current_track( 3179 3714 &self, 3180 3715 request: tonic::Request<super::StreamCurrentTrackRequest>, 3181 3181 - ) -> std::result::Result<tonic::Response<Self::StreamCurrentTrackStream>, tonic::Status>; 3716 3716 + ) -> std::result::Result< 3717 3717 + tonic::Response<Self::StreamCurrentTrackStream>, 3718 3718 + tonic::Status, 3719 3719 + >; 3182 3720 /// Server streaming response type for the StreamStatus method. 3183 3721 type StreamStatusStream: tonic::codegen::tokio_stream::Stream< 3184 3722 Item = std::result::Result<super::StatusResponse, tonic::Status>, 3185 3185 - > + std::marker::Send 3723 3723 + > 3724 3724 + + std::marker::Send 3186 3725 + 'static; 3187 3726 async fn stream_status( 3188 3727 &self, 3189 3728 request: tonic::Request<super::StreamStatusRequest>, 3190 3190 - ) -> std::result::Result<tonic::Response<Self::StreamStatusStream>, tonic::Status>; 3729 3729 + ) -> std::result::Result< 3730 3730 + tonic::Response<Self::StreamStatusStream>, 3731 3731 + tonic::Status, 3732 3732 + >; 3191 3733 /// Server streaming response type for the StreamPlaylist method. 3192 3734 type StreamPlaylistStream: tonic::codegen::tokio_stream::Stream< 3193 3735 Item = std::result::Result<super::PlaylistResponse, tonic::Status>, 3194 3194 - > + std::marker::Send 3736 3736 + > 3737 3737 + + std::marker::Send 3195 3738 + 'static; 3196 3739 async fn stream_playlist( 3197 3740 &self, 3198 3741 request: tonic::Request<super::StreamPlaylistRequest>, 3199 3199 - ) -> std::result::Result<tonic::Response<Self::StreamPlaylistStream>, tonic::Status>; 3742 3742 + ) -> std::result::Result< 3743 3743 + tonic::Response<Self::StreamPlaylistStream>, 3744 3744 + tonic::Status, 3745 3745 + >; 3200 3746 } 3201 3747 #[derive(Debug)] 3202 3748 pub struct PlaybackServiceServer<T> { ··· 3219 3765 max_encoding_message_size: None, 3220 3766 } 3221 3767 } 3222 3222 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 3768 3768 + pub fn with_interceptor<F>( 3769 3769 + inner: T, 3770 3770 + interceptor: F, 3771 3771 + ) -> InterceptedService<Self, F> 3223 3772 where 3224 3773 F: tonic::service::Interceptor, 3225 3774 { ··· 3274 3823 "/rockbox.v1alpha1.PlaybackService/Play" => { 3275 3824 #[allow(non_camel_case_types)] 3276 3825 struct PlaySvc<T: PlaybackService>(pub Arc<T>); 3277 3277 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 3826 3826 + impl< 3827 3827 + T: PlaybackService, 3828 3828 + > tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 3278 3829 type Response = super::PlayResponse; 3279 3279 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3830 3830 + type Future = BoxFuture< 3831 3831 + tonic::Response<Self::Response>, 3832 3832 + tonic::Status, 3833 3833 + >; 3280 3834 fn call( 3281 3835 &mut self, 3282 3836 request: tonic::Request<super::PlayRequest>, 3283 3837 ) -> Self::Future { 3284 3838 let inner = Arc::clone(&self.0); 3285 3285 - let fut = 3286 3286 - async move { <T as PlaybackService>::play(&inner, request).await }; 3839 3839 + let fut = async move { 3840 3840 + <T as PlaybackService>::play(&inner, request).await 3841 3841 + }; 3287 3842 Box::pin(fut) 3288 3843 } 3289 3844 } ··· 3312 3867 "/rockbox.v1alpha1.PlaybackService/Pause" => { 3313 3868 #[allow(non_camel_case_types)] 3314 3869 struct PauseSvc<T: PlaybackService>(pub Arc<T>); 3315 3315 - impl<T: PlaybackService> tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 3870 3870 + impl< 3871 3871 + T: PlaybackService, 3872 3872 + > tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 3316 3873 type Response = super::PauseResponse; 3317 3317 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3874 3874 + type Future = BoxFuture< 3875 3875 + tonic::Response<Self::Response>, 3876 3876 + tonic::Status, 3877 3877 + >; 3318 3878 fn call( 3319 3879 &mut self, 3320 3880 request: tonic::Request<super::PauseRequest>, 3321 3881 ) -> Self::Future { 3322 3882 let inner = Arc::clone(&self.0); 3323 3323 - let fut = 3324 3324 - async move { <T as PlaybackService>::pause(&inner, request).await }; 3883 3883 + let fut = async move { 3884 3884 + <T as PlaybackService>::pause(&inner, request).await 3885 3885 + }; 3325 3886 Box::pin(fut) 3326 3887 } 3327 3888 } ··· 3350 3911 "/rockbox.v1alpha1.PlaybackService/PlayOrPause" => { 3351 3912 #[allow(non_camel_case_types)] 3352 3913 struct PlayOrPauseSvc<T: PlaybackService>(pub Arc<T>); 3353 3353 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayOrPauseRequest> 3354 3354 - for PlayOrPauseSvc<T> 3355 3355 - { 3914 3914 + impl< 3915 3915 + T: PlaybackService, 3916 3916 + > tonic::server::UnaryService<super::PlayOrPauseRequest> 3917 3917 + for PlayOrPauseSvc<T> { 3356 3918 type Response = super::PlayOrPauseResponse; 3357 3357 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3919 3919 + type Future = BoxFuture< 3920 3920 + tonic::Response<Self::Response>, 3921 3921 + tonic::Status, 3922 3922 + >; 3358 3923 fn call( 3359 3924 &mut self, 3360 3925 request: tonic::Request<super::PlayOrPauseRequest>, ··· 3391 3956 "/rockbox.v1alpha1.PlaybackService/Resume" => { 3392 3957 #[allow(non_camel_case_types)] 3393 3958 struct ResumeSvc<T: PlaybackService>(pub Arc<T>); 3394 3394 - impl<T: PlaybackService> tonic::server::UnaryService<super::ResumeRequest> for ResumeSvc<T> { 3959 3959 + impl< 3960 3960 + T: PlaybackService, 3961 3961 + > tonic::server::UnaryService<super::ResumeRequest> 3962 3962 + for ResumeSvc<T> { 3395 3963 type Response = super::ResumeResponse; 3396 3396 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3964 3964 + type Future = BoxFuture< 3965 3965 + tonic::Response<Self::Response>, 3966 3966 + tonic::Status, 3967 3967 + >; 3397 3968 fn call( 3398 3969 &mut self, 3399 3970 request: tonic::Request<super::ResumeRequest>, ··· 3430 4001 "/rockbox.v1alpha1.PlaybackService/Next" => { 3431 4002 #[allow(non_camel_case_types)] 3432 4003 struct NextSvc<T: PlaybackService>(pub Arc<T>); 3433 3433 - impl<T: PlaybackService> tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 4004 4004 + impl< 4005 4005 + T: PlaybackService, 4006 4006 + > tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 3434 4007 type Response = super::NextResponse; 3435 3435 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4008 4008 + type Future = BoxFuture< 4009 4009 + tonic::Response<Self::Response>, 4010 4010 + tonic::Status, 4011 4011 + >; 3436 4012 fn call( 3437 4013 &mut self, 3438 4014 request: tonic::Request<super::NextRequest>, 3439 4015 ) -> Self::Future { 3440 4016 let inner = Arc::clone(&self.0); 3441 3441 - let fut = 3442 3442 - async move { <T as PlaybackService>::next(&inner, request).await }; 4017 4017 + let fut = async move { 4018 4018 + <T as PlaybackService>::next(&inner, request).await 4019 4019 + }; 3443 4020 Box::pin(fut) 3444 4021 } 3445 4022 } ··· 3468 4045 "/rockbox.v1alpha1.PlaybackService/Previous" => { 3469 4046 #[allow(non_camel_case_types)] 3470 4047 struct PreviousSvc<T: PlaybackService>(pub Arc<T>); 3471 3471 - impl<T: PlaybackService> tonic::server::UnaryService<super::PreviousRequest> for PreviousSvc<T> { 4048 4048 + impl< 4049 4049 + T: PlaybackService, 4050 4050 + > tonic::server::UnaryService<super::PreviousRequest> 4051 4051 + for PreviousSvc<T> { 3472 4052 type Response = super::PreviousResponse; 3473 3473 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4053 4053 + type Future = BoxFuture< 4054 4054 + tonic::Response<Self::Response>, 4055 4055 + tonic::Status, 4056 4056 + >; 3474 4057 fn call( 3475 4058 &mut self, 3476 4059 request: tonic::Request<super::PreviousRequest>, ··· 3507 4090 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind" => { 3508 4091 #[allow(non_camel_case_types)] 3509 4092 struct FastForwardRewindSvc<T: PlaybackService>(pub Arc<T>); 3510 3510 - impl<T: PlaybackService> 3511 3511 - tonic::server::UnaryService<super::FastForwardRewindRequest> 3512 3512 - for FastForwardRewindSvc<T> 3513 3513 - { 4093 4093 + impl< 4094 4094 + T: PlaybackService, 4095 4095 + > tonic::server::UnaryService<super::FastForwardRewindRequest> 4096 4096 + for FastForwardRewindSvc<T> { 3514 4097 type Response = super::FastForwardRewindResponse; 3515 3515 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4098 4098 + type Future = BoxFuture< 4099 4099 + tonic::Response<Self::Response>, 4100 4100 + tonic::Status, 4101 4101 + >; 3516 4102 fn call( 3517 4103 &mut self, 3518 4104 request: tonic::Request<super::FastForwardRewindRequest>, 3519 4105 ) -> Self::Future { 3520 4106 let inner = Arc::clone(&self.0); 3521 4107 let fut = async move { 3522 3522 - <T as PlaybackService>::fast_forward_rewind(&inner, request).await 4108 4108 + <T as PlaybackService>::fast_forward_rewind(&inner, request) 4109 4109 + .await 3523 4110 }; 3524 4111 Box::pin(fut) 3525 4112 } ··· 3549 4136 "/rockbox.v1alpha1.PlaybackService/Status" => { 3550 4137 #[allow(non_camel_case_types)] 3551 4138 struct StatusSvc<T: PlaybackService>(pub Arc<T>); 3552 3552 - impl<T: PlaybackService> tonic::server::UnaryService<super::StatusRequest> for StatusSvc<T> { 4139 4139 + impl< 4140 4140 + T: PlaybackService, 4141 4141 + > tonic::server::UnaryService<super::StatusRequest> 4142 4142 + for StatusSvc<T> { 3553 4143 type Response = super::StatusResponse; 3554 3554 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4144 4144 + type Future = BoxFuture< 4145 4145 + tonic::Response<Self::Response>, 4146 4146 + tonic::Status, 4147 4147 + >; 3555 4148 fn call( 3556 4149 &mut self, 3557 4150 request: tonic::Request<super::StatusRequest>, ··· 3588 4181 "/rockbox.v1alpha1.PlaybackService/CurrentTrack" => { 3589 4182 #[allow(non_camel_case_types)] 3590 4183 struct CurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 3591 3591 - impl<T: PlaybackService> tonic::server::UnaryService<super::CurrentTrackRequest> 3592 3592 - for CurrentTrackSvc<T> 3593 3593 - { 4184 4184 + impl< 4185 4185 + T: PlaybackService, 4186 4186 + > tonic::server::UnaryService<super::CurrentTrackRequest> 4187 4187 + for CurrentTrackSvc<T> { 3594 4188 type Response = super::CurrentTrackResponse; 3595 3595 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4189 4189 + type Future = BoxFuture< 4190 4190 + tonic::Response<Self::Response>, 4191 4191 + tonic::Status, 4192 4192 + >; 3596 4193 fn call( 3597 4194 &mut self, 3598 4195 request: tonic::Request<super::CurrentTrackRequest>, ··· 3629 4226 "/rockbox.v1alpha1.PlaybackService/NextTrack" => { 3630 4227 #[allow(non_camel_case_types)] 3631 4228 struct NextTrackSvc<T: PlaybackService>(pub Arc<T>); 3632 3632 - impl<T: PlaybackService> tonic::server::UnaryService<super::NextTrackRequest> for NextTrackSvc<T> { 4229 4229 + impl< 4230 4230 + T: PlaybackService, 4231 4231 + > tonic::server::UnaryService<super::NextTrackRequest> 4232 4232 + for NextTrackSvc<T> { 3633 4233 type Response = super::NextTrackResponse; 3634 3634 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4234 4234 + type Future = BoxFuture< 4235 4235 + tonic::Response<Self::Response>, 4236 4236 + tonic::Status, 4237 4237 + >; 3635 4238 fn call( 3636 4239 &mut self, 3637 4240 request: tonic::Request<super::NextTrackRequest>, ··· 3668 4271 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks" => { 3669 4272 #[allow(non_camel_case_types)] 3670 4273 struct FlushAndReloadTracksSvc<T: PlaybackService>(pub Arc<T>); 3671 3671 - impl<T: PlaybackService> 3672 3672 - tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3673 3673 - for FlushAndReloadTracksSvc<T> 3674 3674 - { 4274 4274 + impl< 4275 4275 + T: PlaybackService, 4276 4276 + > tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 4277 4277 + for FlushAndReloadTracksSvc<T> { 3675 4278 type Response = super::FlushAndReloadTracksResponse; 3676 3676 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4279 4279 + type Future = BoxFuture< 4280 4280 + tonic::Response<Self::Response>, 4281 4281 + tonic::Status, 4282 4282 + >; 3677 4283 fn call( 3678 4284 &mut self, 3679 4285 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3680 4286 ) -> Self::Future { 3681 4287 let inner = Arc::clone(&self.0); 3682 4288 let fut = async move { 3683 3683 - <T as PlaybackService>::flush_and_reload_tracks(&inner, request) 4289 4289 + <T as PlaybackService>::flush_and_reload_tracks( 4290 4290 + &inner, 4291 4291 + request, 4292 4292 + ) 3684 4293 .await 3685 4294 }; 3686 4295 Box::pin(fut) ··· 3711 4320 "/rockbox.v1alpha1.PlaybackService/GetFilePosition" => { 3712 4321 #[allow(non_camel_case_types)] 3713 4322 struct GetFilePositionSvc<T: PlaybackService>(pub Arc<T>); 3714 3714 - impl<T: PlaybackService> 3715 3715 - tonic::server::UnaryService<super::GetFilePositionRequest> 3716 3716 - for GetFilePositionSvc<T> 3717 3717 - { 4323 4323 + impl< 4324 4324 + T: PlaybackService, 4325 4325 + > tonic::server::UnaryService<super::GetFilePositionRequest> 4326 4326 + for GetFilePositionSvc<T> { 3718 4327 type Response = super::GetFilePositionResponse; 3719 3719 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4328 4328 + type Future = BoxFuture< 4329 4329 + tonic::Response<Self::Response>, 4330 4330 + tonic::Status, 4331 4331 + >; 3720 4332 fn call( 3721 4333 &mut self, 3722 4334 request: tonic::Request<super::GetFilePositionRequest>, 3723 4335 ) -> Self::Future { 3724 4336 let inner = Arc::clone(&self.0); 3725 4337 let fut = async move { 3726 3726 - <T as PlaybackService>::get_file_position(&inner, request).await 4338 4338 + <T as PlaybackService>::get_file_position(&inner, request) 4339 4339 + .await 3727 4340 }; 3728 4341 Box::pin(fut) 3729 4342 } ··· 3753 4366 "/rockbox.v1alpha1.PlaybackService/HardStop" => { 3754 4367 #[allow(non_camel_case_types)] 3755 4368 struct HardStopSvc<T: PlaybackService>(pub Arc<T>); 3756 3756 - impl<T: PlaybackService> tonic::server::UnaryService<super::HardStopRequest> for HardStopSvc<T> { 4369 4369 + impl< 4370 4370 + T: PlaybackService, 4371 4371 + > tonic::server::UnaryService<super::HardStopRequest> 4372 4372 + for HardStopSvc<T> { 3757 4373 type Response = super::HardStopResponse; 3758 3758 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4374 4374 + type Future = BoxFuture< 4375 4375 + tonic::Response<Self::Response>, 4376 4376 + tonic::Status, 4377 4377 + >; 3759 4378 fn call( 3760 4379 &mut self, 3761 4380 request: tonic::Request<super::HardStopRequest>, ··· 3792 4411 "/rockbox.v1alpha1.PlaybackService/PlayAlbum" => { 3793 4412 #[allow(non_camel_case_types)] 3794 4413 struct PlayAlbumSvc<T: PlaybackService>(pub Arc<T>); 3795 3795 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayAlbumRequest> for PlayAlbumSvc<T> { 4414 4414 + impl< 4415 4415 + T: PlaybackService, 4416 4416 + > tonic::server::UnaryService<super::PlayAlbumRequest> 4417 4417 + for PlayAlbumSvc<T> { 3796 4418 type Response = super::PlayAlbumResponse; 3797 3797 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4419 4419 + type Future = BoxFuture< 4420 4420 + tonic::Response<Self::Response>, 4421 4421 + tonic::Status, 4422 4422 + >; 3798 4423 fn call( 3799 4424 &mut self, 3800 4425 request: tonic::Request<super::PlayAlbumRequest>, ··· 3831 4456 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks" => { 3832 4457 #[allow(non_camel_case_types)] 3833 4458 struct PlayArtistTracksSvc<T: PlaybackService>(pub Arc<T>); 3834 3834 - impl<T: PlaybackService> 3835 3835 - tonic::server::UnaryService<super::PlayArtistTracksRequest> 3836 3836 - for PlayArtistTracksSvc<T> 3837 3837 - { 4459 4459 + impl< 4460 4460 + T: PlaybackService, 4461 4461 + > tonic::server::UnaryService<super::PlayArtistTracksRequest> 4462 4462 + for PlayArtistTracksSvc<T> { 3838 4463 type Response = super::PlayArtistTracksResponse; 3839 3839 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4464 4464 + type Future = BoxFuture< 4465 4465 + tonic::Response<Self::Response>, 4466 4466 + tonic::Status, 4467 4467 + >; 3840 4468 fn call( 3841 4469 &mut self, 3842 4470 request: tonic::Request<super::PlayArtistTracksRequest>, 3843 4471 ) -> Self::Future { 3844 4472 let inner = Arc::clone(&self.0); 3845 4473 let fut = async move { 3846 3846 - <T as PlaybackService>::play_artist_tracks(&inner, request).await 4474 4474 + <T as PlaybackService>::play_artist_tracks(&inner, request) 4475 4475 + .await 3847 4476 }; 3848 4477 Box::pin(fut) 3849 4478 } ··· 3873 4502 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist" => { 3874 4503 #[allow(non_camel_case_types)] 3875 4504 struct PlayPlaylistSvc<T: PlaybackService>(pub Arc<T>); 3876 3876 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayPlaylistRequest> 3877 3877 - for PlayPlaylistSvc<T> 3878 3878 - { 4505 4505 + impl< 4506 4506 + T: PlaybackService, 4507 4507 + > tonic::server::UnaryService<super::PlayPlaylistRequest> 4508 4508 + for PlayPlaylistSvc<T> { 3879 4509 type Response = super::PlayPlaylistResponse; 3880 3880 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4510 4510 + type Future = BoxFuture< 4511 4511 + tonic::Response<Self::Response>, 4512 4512 + tonic::Status, 4513 4513 + >; 3881 4514 fn call( 3882 4515 &mut self, 3883 4516 request: tonic::Request<super::PlayPlaylistRequest>, ··· 3914 4547 "/rockbox.v1alpha1.PlaybackService/PlayDirectory" => { 3915 4548 #[allow(non_camel_case_types)] 3916 4549 struct PlayDirectorySvc<T: PlaybackService>(pub Arc<T>); 3917 3917 - impl<T: PlaybackService> 3918 3918 - tonic::server::UnaryService<super::PlayDirectoryRequest> 3919 3919 - for PlayDirectorySvc<T> 3920 3920 - { 4550 4550 + impl< 4551 4551 + T: PlaybackService, 4552 4552 + > tonic::server::UnaryService<super::PlayDirectoryRequest> 4553 4553 + for PlayDirectorySvc<T> { 3921 4554 type Response = super::PlayDirectoryResponse; 3922 3922 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4555 4555 + type Future = BoxFuture< 4556 4556 + tonic::Response<Self::Response>, 4557 4557 + tonic::Status, 4558 4558 + >; 3923 4559 fn call( 3924 4560 &mut self, 3925 4561 request: tonic::Request<super::PlayDirectoryRequest>, 3926 4562 ) -> Self::Future { 3927 4563 let inner = Arc::clone(&self.0); 3928 4564 let fut = async move { 3929 3929 - <T as PlaybackService>::play_directory(&inner, request).await 4565 4565 + <T as PlaybackService>::play_directory(&inner, request) 4566 4566 + .await 3930 4567 }; 3931 4568 Box::pin(fut) 3932 4569 } ··· 3956 4593 "/rockbox.v1alpha1.PlaybackService/PlayTrack" => { 3957 4594 #[allow(non_camel_case_types)] 3958 4595 struct PlayTrackSvc<T: PlaybackService>(pub Arc<T>); 3959 3959 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayTrackRequest> for PlayTrackSvc<T> { 4596 4596 + impl< 4597 4597 + T: PlaybackService, 4598 4598 + > tonic::server::UnaryService<super::PlayTrackRequest> 4599 4599 + for PlayTrackSvc<T> { 3960 4600 type Response = super::PlayTrackResponse; 3961 3961 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4601 4601 + type Future = BoxFuture< 4602 4602 + tonic::Response<Self::Response>, 4603 4603 + tonic::Status, 4604 4604 + >; 3962 4605 fn call( 3963 4606 &mut self, 3964 4607 request: tonic::Request<super::PlayTrackRequest>, ··· 3995 4638 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks" => { 3996 4639 #[allow(non_camel_case_types)] 3997 4640 struct PlayLikedTracksSvc<T: PlaybackService>(pub Arc<T>); 3998 3998 - impl<T: PlaybackService> 3999 3999 - tonic::server::UnaryService<super::PlayLikedTracksRequest> 4000 4000 - for PlayLikedTracksSvc<T> 4001 4001 - { 4641 4641 + impl< 4642 4642 + T: PlaybackService, 4643 4643 + > tonic::server::UnaryService<super::PlayLikedTracksRequest> 4644 4644 + for PlayLikedTracksSvc<T> { 4002 4645 type Response = super::PlayLikedTracksResponse; 4003 4003 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4646 4646 + type Future = BoxFuture< 4647 4647 + tonic::Response<Self::Response>, 4648 4648 + tonic::Status, 4649 4649 + >; 4004 4650 fn call( 4005 4651 &mut self, 4006 4652 request: tonic::Request<super::PlayLikedTracksRequest>, 4007 4653 ) -> Self::Future { 4008 4654 let inner = Arc::clone(&self.0); 4009 4655 let fut = async move { 4010 4010 - <T as PlaybackService>::play_liked_tracks(&inner, request).await 4656 4656 + <T as PlaybackService>::play_liked_tracks(&inner, request) 4657 4657 + .await 4011 4658 }; 4012 4659 Box::pin(fut) 4013 4660 } ··· 4037 4684 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks" => { 4038 4685 #[allow(non_camel_case_types)] 4039 4686 struct PlayAllTracksSvc<T: PlaybackService>(pub Arc<T>); 4040 4040 - impl<T: PlaybackService> 4041 4041 - tonic::server::UnaryService<super::PlayAllTracksRequest> 4042 4042 - for PlayAllTracksSvc<T> 4043 4043 - { 4687 4687 + impl< 4688 4688 + T: PlaybackService, 4689 4689 + > tonic::server::UnaryService<super::PlayAllTracksRequest> 4690 4690 + for PlayAllTracksSvc<T> { 4044 4691 type Response = super::PlayAllTracksResponse; 4045 4045 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4692 4692 + type Future = BoxFuture< 4693 4693 + tonic::Response<Self::Response>, 4694 4694 + tonic::Status, 4695 4695 + >; 4046 4696 fn call( 4047 4697 &mut self, 4048 4698 request: tonic::Request<super::PlayAllTracksRequest>, 4049 4699 ) -> Self::Future { 4050 4700 let inner = Arc::clone(&self.0); 4051 4701 let fut = async move { 4052 4052 - <T as PlaybackService>::play_all_tracks(&inner, request).await 4702 4702 + <T as PlaybackService>::play_all_tracks(&inner, request) 4703 4703 + .await 4053 4704 }; 4054 4705 Box::pin(fut) 4055 4706 } ··· 4079 4730 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack" => { 4080 4731 #[allow(non_camel_case_types)] 4081 4732 struct StreamCurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 4082 4082 - impl<T: PlaybackService> 4083 4083 - tonic::server::ServerStreamingService<super::StreamCurrentTrackRequest> 4084 4084 - for StreamCurrentTrackSvc<T> 4085 4085 - { 4733 4733 + impl< 4734 4734 + T: PlaybackService, 4735 4735 + > tonic::server::ServerStreamingService< 4736 4736 + super::StreamCurrentTrackRequest, 4737 4737 + > for StreamCurrentTrackSvc<T> { 4086 4738 type Response = super::CurrentTrackResponse; 4087 4739 type ResponseStream = T::StreamCurrentTrackStream; 4088 4088 - type Future = 4089 4089 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4740 4740 + type Future = BoxFuture< 4741 4741 + tonic::Response<Self::ResponseStream>, 4742 4742 + tonic::Status, 4743 4743 + >; 4090 4744 fn call( 4091 4745 &mut self, 4092 4746 request: tonic::Request<super::StreamCurrentTrackRequest>, 4093 4747 ) -> Self::Future { 4094 4748 let inner = Arc::clone(&self.0); 4095 4749 let fut = async move { 4096 4096 - <T as PlaybackService>::stream_current_track(&inner, request).await 4750 4750 + <T as PlaybackService>::stream_current_track( 4751 4751 + &inner, 4752 4752 + request, 4753 4753 + ) 4754 4754 + .await 4097 4755 }; 4098 4756 Box::pin(fut) 4099 4757 } ··· 4123 4781 "/rockbox.v1alpha1.PlaybackService/StreamStatus" => { 4124 4782 #[allow(non_camel_case_types)] 4125 4783 struct StreamStatusSvc<T: PlaybackService>(pub Arc<T>); 4126 4126 - impl<T: PlaybackService> 4127 4127 - tonic::server::ServerStreamingService<super::StreamStatusRequest> 4128 4128 - for StreamStatusSvc<T> 4129 4129 - { 4784 4784 + impl< 4785 4785 + T: PlaybackService, 4786 4786 + > tonic::server::ServerStreamingService<super::StreamStatusRequest> 4787 4787 + for StreamStatusSvc<T> { 4130 4788 type Response = super::StatusResponse; 4131 4789 type ResponseStream = T::StreamStatusStream; 4132 4132 - type Future = 4133 4133 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4790 4790 + type Future = BoxFuture< 4791 4791 + tonic::Response<Self::ResponseStream>, 4792 4792 + tonic::Status, 4793 4793 + >; 4134 4794 fn call( 4135 4795 &mut self, 4136 4796 request: tonic::Request<super::StreamStatusRequest>, ··· 4167 4827 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist" => { 4168 4828 #[allow(non_camel_case_types)] 4169 4829 struct StreamPlaylistSvc<T: PlaybackService>(pub Arc<T>); 4170 4170 - impl<T: PlaybackService> 4171 4171 - tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 4172 4172 - for StreamPlaylistSvc<T> 4173 4173 - { 4830 4830 + impl< 4831 4831 + T: PlaybackService, 4832 4832 + > tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 4833 4833 + for StreamPlaylistSvc<T> { 4174 4834 type Response = super::PlaylistResponse; 4175 4835 type ResponseStream = T::StreamPlaylistStream; 4176 4176 - type Future = 4177 4177 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4836 4836 + type Future = BoxFuture< 4837 4837 + tonic::Response<Self::ResponseStream>, 4838 4838 + tonic::Status, 4839 4839 + >; 4178 4840 fn call( 4179 4841 &mut self, 4180 4842 request: tonic::Request<super::StreamPlaylistRequest>, 4181 4843 ) -> Self::Future { 4182 4844 let inner = Arc::clone(&self.0); 4183 4845 let fut = async move { 4184 4184 - <T as PlaybackService>::stream_playlist(&inner, request).await 4846 4846 + <T as PlaybackService>::stream_playlist(&inner, request) 4847 4847 + .await 4185 4848 }; 4186 4849 Box::pin(fut) 4187 4850 } ··· 4208 4871 }; 4209 4872 Box::pin(fut) 4210 4873 } 4211 4211 - _ => Box::pin(async move { 4212 4212 - let mut response = http::Response::new(empty_body()); 4213 4213 - let headers = response.headers_mut(); 4214 4214 - headers.insert( 4215 4215 - tonic::Status::GRPC_STATUS, 4216 4216 - (tonic::Code::Unimplemented as i32).into(), 4217 4217 - ); 4218 4218 - headers.insert( 4219 4219 - http::header::CONTENT_TYPE, 4220 4220 - tonic::metadata::GRPC_CONTENT_TYPE, 4221 4221 - ); 4222 4222 - Ok(response) 4223 4223 - }), 4874 4874 + _ => { 4875 4875 + Box::pin(async move { 4876 4876 + let mut response = http::Response::new(empty_body()); 4877 4877 + let headers = response.headers_mut(); 4878 4878 + headers 4879 4879 + .insert( 4880 4880 + tonic::Status::GRPC_STATUS, 4881 4881 + (tonic::Code::Unimplemented as i32).into(), 4882 4882 + ); 4883 4883 + headers 4884 4884 + .insert( 4885 4885 + http::header::CONTENT_TYPE, 4886 4886 + tonic::metadata::GRPC_CONTENT_TYPE, 4887 4887 + ); 4888 4888 + Ok(response) 4889 4889 + }) 4890 4890 + } 4224 4891 } 4225 4892 } 4226 4893 } ··· 4427 5094 dead_code, 4428 5095 missing_docs, 4429 5096 clippy::wildcard_imports, 4430 4430 - clippy::let_unit_value 5097 5097 + clippy::let_unit_value, 4431 5098 )] 4432 4432 - use tonic::codegen::http::Uri; 4433 5099 use tonic::codegen::*; 5100 5100 + use tonic::codegen::http::Uri; 4434 5101 #[derive(Debug, Clone)] 4435 5102 pub struct PlaylistServiceClient<T> { 4436 5103 inner: tonic::client::Grpc<T>, ··· 4474 5141 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 4475 5142 >, 4476 5143 >, 4477 4477 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 4478 4478 - Into<StdError> + std::marker::Send + std::marker::Sync, 5144 5144 + <T as tonic::codegen::Service< 5145 5145 + http::Request<tonic::body::BoxBody>, 5146 5146 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 4479 5147 { 4480 5148 PlaylistServiceClient::new(InterceptedService::new(inner, interceptor)) 4481 5149 } ··· 4513 5181 pub async fn get_current( 4514 5182 &mut self, 4515 5183 request: impl tonic::IntoRequest<super::GetCurrentRequest>, 4516 4516 - ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status> 4517 4517 - { 4518 4518 - self.inner.ready().await.map_err(|e| { 4519 4519 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4520 4520 - })?; 5184 5184 + ) -> std::result::Result< 5185 5185 + tonic::Response<super::GetCurrentResponse>, 5186 5186 + tonic::Status, 5187 5187 + > { 5188 5188 + self.inner 5189 5189 + .ready() 5190 5190 + .await 5191 5191 + .map_err(|e| { 5192 5192 + tonic::Status::unknown( 5193 5193 + format!("Service was not ready: {}", e.into()), 5194 5194 + ) 5195 5195 + })?; 4521 5196 let codec = tonic::codec::ProstCodec::default(); 4522 5197 let path = http::uri::PathAndQuery::from_static( 4523 5198 "/rockbox.v1alpha1.PlaylistService/GetCurrent", 4524 5199 ); 4525 5200 let mut req = request.into_request(); 4526 4526 - req.extensions_mut().insert(GrpcMethod::new( 4527 4527 - "rockbox.v1alpha1.PlaylistService", 4528 4528 - "GetCurrent", 4529 4529 - )); 5201 5201 + req.extensions_mut() 5202 5202 + .insert( 5203 5203 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetCurrent"), 5204 5204 + ); 4530 5205 self.inner.unary(req, path, codec).await 4531 5206 } 4532 5207 pub async fn get_resume_info( 4533 5208 &mut self, 4534 5209 request: impl tonic::IntoRequest<super::GetResumeInfoRequest>, 4535 4535 - ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status> 4536 4536 - { 4537 4537 - self.inner.ready().await.map_err(|e| { 4538 4538 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4539 4539 - })?; 5210 5210 + ) -> std::result::Result< 5211 5211 + tonic::Response<super::GetResumeInfoResponse>, 5212 5212 + tonic::Status, 5213 5213 + > { 5214 5214 + self.inner 5215 5215 + .ready() 5216 5216 + .await 5217 5217 + .map_err(|e| { 5218 5218 + tonic::Status::unknown( 5219 5219 + format!("Service was not ready: {}", e.into()), 5220 5220 + ) 5221 5221 + })?; 4540 5222 let codec = tonic::codec::ProstCodec::default(); 4541 5223 let path = http::uri::PathAndQuery::from_static( 4542 5224 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo", 4543 5225 ); 4544 5226 let mut req = request.into_request(); 4545 4545 - req.extensions_mut().insert(GrpcMethod::new( 4546 4546 - "rockbox.v1alpha1.PlaylistService", 4547 4547 - "GetResumeInfo", 4548 4548 - )); 5227 5227 + req.extensions_mut() 5228 5228 + .insert( 5229 5229 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetResumeInfo"), 5230 5230 + ); 4549 5231 self.inner.unary(req, path, codec).await 4550 5232 } 4551 5233 pub async fn get_track_info( 4552 5234 &mut self, 4553 5235 request: impl tonic::IntoRequest<super::GetTrackInfoRequest>, 4554 4554 - ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status> 4555 4555 - { 4556 4556 - self.inner.ready().await.map_err(|e| { 4557 4557 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4558 4558 - })?; 5236 5236 + ) -> std::result::Result< 5237 5237 + tonic::Response<super::GetTrackInfoResponse>, 5238 5238 + tonic::Status, 5239 5239 + > { 5240 5240 + self.inner 5241 5241 + .ready() 5242 5242 + .await 5243 5243 + .map_err(|e| { 5244 5244 + tonic::Status::unknown( 5245 5245 + format!("Service was not ready: {}", e.into()), 5246 5246 + ) 5247 5247 + })?; 4559 5248 let codec = tonic::codec::ProstCodec::default(); 4560 5249 let path = http::uri::PathAndQuery::from_static( 4561 5250 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo", 4562 5251 ); 4563 5252 let mut req = request.into_request(); 4564 4564 - req.extensions_mut().insert(GrpcMethod::new( 4565 4565 - "rockbox.v1alpha1.PlaylistService", 4566 4566 - "GetTrackInfo", 4567 4567 - )); 5253 5253 + req.extensions_mut() 5254 5254 + .insert( 5255 5255 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetTrackInfo"), 5256 5256 + ); 4568 5257 self.inner.unary(req, path, codec).await 4569 5258 } 4570 5259 pub async fn get_first_index( 4571 5260 &mut self, 4572 5261 request: impl tonic::IntoRequest<super::GetFirstIndexRequest>, 4573 4573 - ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status> 4574 4574 - { 4575 4575 - self.inner.ready().await.map_err(|e| { 4576 4576 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4577 4577 - })?; 5262 5262 + ) -> std::result::Result< 5263 5263 + tonic::Response<super::GetFirstIndexResponse>, 5264 5264 + tonic::Status, 5265 5265 + > { 5266 5266 + self.inner 5267 5267 + .ready() 5268 5268 + .await 5269 5269 + .map_err(|e| { 5270 5270 + tonic::Status::unknown( 5271 5271 + format!("Service was not ready: {}", e.into()), 5272 5272 + ) 5273 5273 + })?; 4578 5274 let codec = tonic::codec::ProstCodec::default(); 4579 5275 let path = http::uri::PathAndQuery::from_static( 4580 5276 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex", 4581 5277 ); 4582 5278 let mut req = request.into_request(); 4583 4583 - req.extensions_mut().insert(GrpcMethod::new( 4584 4584 - "rockbox.v1alpha1.PlaylistService", 4585 4585 - "GetFirstIndex", 4586 4586 - )); 5279 5279 + req.extensions_mut() 5280 5280 + .insert( 5281 5281 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetFirstIndex"), 5282 5282 + ); 4587 5283 self.inner.unary(req, path, codec).await 4588 5284 } 4589 5285 pub async fn get_display_index( 4590 5286 &mut self, 4591 5287 request: impl tonic::IntoRequest<super::GetDisplayIndexRequest>, 4592 4592 - ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status> 4593 4593 - { 4594 4594 - self.inner.ready().await.map_err(|e| { 4595 4595 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4596 4596 - })?; 5288 5288 + ) -> std::result::Result< 5289 5289 + tonic::Response<super::GetDisplayIndexResponse>, 5290 5290 + tonic::Status, 5291 5291 + > { 5292 5292 + self.inner 5293 5293 + .ready() 5294 5294 + .await 5295 5295 + .map_err(|e| { 5296 5296 + tonic::Status::unknown( 5297 5297 + format!("Service was not ready: {}", e.into()), 5298 5298 + ) 5299 5299 + })?; 4597 5300 let codec = tonic::codec::ProstCodec::default(); 4598 5301 let path = http::uri::PathAndQuery::from_static( 4599 5302 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex", 4600 5303 ); 4601 5304 let mut req = request.into_request(); 4602 4602 - req.extensions_mut().insert(GrpcMethod::new( 4603 4603 - "rockbox.v1alpha1.PlaylistService", 4604 4604 - "GetDisplayIndex", 4605 4605 - )); 5305 5305 + req.extensions_mut() 5306 5306 + .insert( 5307 5307 + GrpcMethod::new( 5308 5308 + "rockbox.v1alpha1.PlaylistService", 5309 5309 + "GetDisplayIndex", 5310 5310 + ), 5311 5311 + ); 4606 5312 self.inner.unary(req, path, codec).await 4607 5313 } 4608 5314 pub async fn amount( 4609 5315 &mut self, 4610 5316 request: impl tonic::IntoRequest<super::AmountRequest>, 4611 5317 ) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status> { 4612 4612 - self.inner.ready().await.map_err(|e| { 4613 4613 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4614 4614 - })?; 5318 5318 + self.inner 5319 5319 + .ready() 5320 5320 + .await 5321 5321 + .map_err(|e| { 5322 5322 + tonic::Status::unknown( 5323 5323 + format!("Service was not ready: {}", e.into()), 5324 5324 + ) 5325 5325 + })?; 4615 5326 let codec = tonic::codec::ProstCodec::default(); 4616 4616 - let path = 4617 4617 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Amount"); 5327 5327 + let path = http::uri::PathAndQuery::from_static( 5328 5328 + "/rockbox.v1alpha1.PlaylistService/Amount", 5329 5329 + ); 4618 5330 let mut req = request.into_request(); 4619 4619 - req.extensions_mut().insert(GrpcMethod::new( 4620 4620 - "rockbox.v1alpha1.PlaylistService", 4621 4621 - "Amount", 4622 4622 - )); 5331 5331 + req.extensions_mut() 5332 5332 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Amount")); 4623 5333 self.inner.unary(req, path, codec).await 4624 5334 } 4625 5335 pub async fn playlist_resume( 4626 5336 &mut self, 4627 5337 request: impl tonic::IntoRequest<super::PlaylistResumeRequest>, 4628 4628 - ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status> 4629 4629 - { 4630 4630 - self.inner.ready().await.map_err(|e| { 4631 4631 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4632 4632 - })?; 5338 5338 + ) -> std::result::Result< 5339 5339 + tonic::Response<super::PlaylistResumeResponse>, 5340 5340 + tonic::Status, 5341 5341 + > { 5342 5342 + self.inner 5343 5343 + .ready() 5344 5344 + .await 5345 5345 + .map_err(|e| { 5346 5346 + tonic::Status::unknown( 5347 5347 + format!("Service was not ready: {}", e.into()), 5348 5348 + ) 5349 5349 + })?; 4633 5350 let codec = tonic::codec::ProstCodec::default(); 4634 5351 let path = http::uri::PathAndQuery::from_static( 4635 5352 "/rockbox.v1alpha1.PlaylistService/PlaylistResume", 4636 5353 ); 4637 5354 let mut req = request.into_request(); 4638 4638 - req.extensions_mut().insert(GrpcMethod::new( 4639 4639 - "rockbox.v1alpha1.PlaylistService", 4640 4640 - "PlaylistResume", 4641 4641 - )); 5355 5355 + req.extensions_mut() 5356 5356 + .insert( 5357 5357 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "PlaylistResume"), 5358 5358 + ); 4642 5359 self.inner.unary(req, path, codec).await 4643 5360 } 4644 5361 pub async fn resume_track( 4645 5362 &mut self, 4646 5363 request: impl tonic::IntoRequest<super::ResumeTrackRequest>, 4647 4647 - ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status> 4648 4648 - { 4649 4649 - self.inner.ready().await.map_err(|e| { 4650 4650 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4651 4651 - })?; 5364 5364 + ) -> std::result::Result< 5365 5365 + tonic::Response<super::ResumeTrackResponse>, 5366 5366 + tonic::Status, 5367 5367 + > { 5368 5368 + self.inner 5369 5369 + .ready() 5370 5370 + .await 5371 5371 + .map_err(|e| { 5372 5372 + tonic::Status::unknown( 5373 5373 + format!("Service was not ready: {}", e.into()), 5374 5374 + ) 5375 5375 + })?; 4652 5376 let codec = tonic::codec::ProstCodec::default(); 4653 5377 let path = http::uri::PathAndQuery::from_static( 4654 5378 "/rockbox.v1alpha1.PlaylistService/ResumeTrack", 4655 5379 ); 4656 5380 let mut req = request.into_request(); 4657 4657 - req.extensions_mut().insert(GrpcMethod::new( 4658 4658 - "rockbox.v1alpha1.PlaylistService", 4659 4659 - "ResumeTrack", 4660 4660 - )); 5381 5381 + req.extensions_mut() 5382 5382 + .insert( 5383 5383 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "ResumeTrack"), 5384 5384 + ); 4661 5385 self.inner.unary(req, path, codec).await 4662 5386 } 4663 5387 pub async fn set_modified( 4664 5388 &mut self, 4665 5389 request: impl tonic::IntoRequest<super::SetModifiedRequest>, 4666 4666 - ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status> 4667 4667 - { 4668 4668 - self.inner.ready().await.map_err(|e| { 4669 4669 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4670 4670 - })?; 5390 5390 + ) -> std::result::Result< 5391 5391 + tonic::Response<super::SetModifiedResponse>, 5392 5392 + tonic::Status, 5393 5393 + > { 5394 5394 + self.inner 5395 5395 + .ready() 5396 5396 + .await 5397 5397 + .map_err(|e| { 5398 5398 + tonic::Status::unknown( 5399 5399 + format!("Service was not ready: {}", e.into()), 5400 5400 + ) 5401 5401 + })?; 4671 5402 let codec = tonic::codec::ProstCodec::default(); 4672 5403 let path = http::uri::PathAndQuery::from_static( 4673 5404 "/rockbox.v1alpha1.PlaylistService/SetModified", 4674 5405 ); 4675 5406 let mut req = request.into_request(); 4676 4676 - req.extensions_mut().insert(GrpcMethod::new( 4677 4677 - "rockbox.v1alpha1.PlaylistService", 4678 4678 - "SetModified", 4679 4679 - )); 5407 5407 + req.extensions_mut() 5408 5408 + .insert( 5409 5409 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "SetModified"), 5410 5410 + ); 4680 5411 self.inner.unary(req, path, codec).await 4681 5412 } 4682 5413 pub async fn start( 4683 5414 &mut self, 4684 5415 request: impl tonic::IntoRequest<super::StartRequest>, 4685 5416 ) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status> { 4686 4686 - self.inner.ready().await.map_err(|e| { 4687 4687 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4688 4688 - })?; 5417 5417 + self.inner 5418 5418 + .ready() 5419 5419 + .await 5420 5420 + .map_err(|e| { 5421 5421 + tonic::Status::unknown( 5422 5422 + format!("Service was not ready: {}", e.into()), 5423 5423 + ) 5424 5424 + })?; 4689 5425 let codec = tonic::codec::ProstCodec::default(); 4690 4690 - let path = 4691 4691 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Start"); 5426 5426 + let path = http::uri::PathAndQuery::from_static( 5427 5427 + "/rockbox.v1alpha1.PlaylistService/Start", 5428 5428 + ); 4692 5429 let mut req = request.into_request(); 4693 5430 req.extensions_mut() 4694 5431 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Start")); ··· 4698 5435 &mut self, 4699 5436 request: impl tonic::IntoRequest<super::SyncRequest>, 4700 5437 ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> { 4701 4701 - self.inner.ready().await.map_err(|e| { 4702 4702 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4703 4703 - })?; 5438 5438 + self.inner 5439 5439 + .ready() 5440 5440 + .await 5441 5441 + .map_err(|e| { 5442 5442 + tonic::Status::unknown( 5443 5443 + format!("Service was not ready: {}", e.into()), 5444 5444 + ) 5445 5445 + })?; 4704 5446 let codec = tonic::codec::ProstCodec::default(); 4705 4705 - let path = 4706 4706 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Sync"); 5447 5447 + let path = http::uri::PathAndQuery::from_static( 5448 5448 + "/rockbox.v1alpha1.PlaylistService/Sync", 5449 5449 + ); 4707 5450 let mut req = request.into_request(); 4708 5451 req.extensions_mut() 4709 5452 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Sync")); ··· 4712 5455 pub async fn remove_all_tracks( 4713 5456 &mut self, 4714 5457 request: impl tonic::IntoRequest<super::RemoveAllTracksRequest>, 4715 4715 - ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status> 4716 4716 - { 4717 4717 - self.inner.ready().await.map_err(|e| { 4718 4718 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4719 4719 - })?; 5458 5458 + ) -> std::result::Result< 5459 5459 + tonic::Response<super::RemoveAllTracksResponse>, 5460 5460 + tonic::Status, 5461 5461 + > { 5462 5462 + self.inner 5463 5463 + .ready() 5464 5464 + .await 5465 5465 + .map_err(|e| { 5466 5466 + tonic::Status::unknown( 5467 5467 + format!("Service was not ready: {}", e.into()), 5468 5468 + ) 5469 5469 + })?; 4720 5470 let codec = tonic::codec::ProstCodec::default(); 4721 5471 let path = http::uri::PathAndQuery::from_static( 4722 5472 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks", 4723 5473 ); 4724 5474 let mut req = request.into_request(); 4725 4725 - req.extensions_mut().insert(GrpcMethod::new( 4726 4726 - "rockbox.v1alpha1.PlaylistService", 4727 4727 - "RemoveAllTracks", 4728 4728 - )); 5475 5475 + req.extensions_mut() 5476 5476 + .insert( 5477 5477 + GrpcMethod::new( 5478 5478 + "rockbox.v1alpha1.PlaylistService", 5479 5479 + "RemoveAllTracks", 5480 5480 + ), 5481 5481 + ); 4729 5482 self.inner.unary(req, path, codec).await 4730 5483 } 4731 5484 pub async fn remove_tracks( 4732 5485 &mut self, 4733 5486 request: impl tonic::IntoRequest<super::RemoveTracksRequest>, 4734 4734 - ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status> 4735 4735 - { 4736 4736 - self.inner.ready().await.map_err(|e| { 4737 4737 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4738 4738 - })?; 5487 5487 + ) -> std::result::Result< 5488 5488 + tonic::Response<super::RemoveTracksResponse>, 5489 5489 + tonic::Status, 5490 5490 + > { 5491 5491 + self.inner 5492 5492 + .ready() 5493 5493 + .await 5494 5494 + .map_err(|e| { 5495 5495 + tonic::Status::unknown( 5496 5496 + format!("Service was not ready: {}", e.into()), 5497 5497 + ) 5498 5498 + })?; 4739 5499 let codec = tonic::codec::ProstCodec::default(); 4740 5500 let path = http::uri::PathAndQuery::from_static( 4741 5501 "/rockbox.v1alpha1.PlaylistService/RemoveTracks", 4742 5502 ); 4743 5503 let mut req = request.into_request(); 4744 4744 - req.extensions_mut().insert(GrpcMethod::new( 4745 4745 - "rockbox.v1alpha1.PlaylistService", 4746 4746 - "RemoveTracks", 4747 4747 - )); 5504 5504 + req.extensions_mut() 5505 5505 + .insert( 5506 5506 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "RemoveTracks"), 5507 5507 + ); 4748 5508 self.inner.unary(req, path, codec).await 4749 5509 } 4750 5510 pub async fn create_playlist( 4751 5511 &mut self, 4752 5512 request: impl tonic::IntoRequest<super::CreatePlaylistRequest>, 4753 4753 - ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status> 4754 4754 - { 4755 4755 - self.inner.ready().await.map_err(|e| { 4756 4756 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4757 4757 - })?; 5513 5513 + ) -> std::result::Result< 5514 5514 + tonic::Response<super::CreatePlaylistResponse>, 5515 5515 + tonic::Status, 5516 5516 + > { 5517 5517 + self.inner 5518 5518 + .ready() 5519 5519 + .await 5520 5520 + .map_err(|e| { 5521 5521 + tonic::Status::unknown( 5522 5522 + format!("Service was not ready: {}", e.into()), 5523 5523 + ) 5524 5524 + })?; 4758 5525 let codec = tonic::codec::ProstCodec::default(); 4759 5526 let path = http::uri::PathAndQuery::from_static( 4760 5527 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist", 4761 5528 ); 4762 5529 let mut req = request.into_request(); 4763 4763 - req.extensions_mut().insert(GrpcMethod::new( 4764 4764 - "rockbox.v1alpha1.PlaylistService", 4765 4765 - "CreatePlaylist", 4766 4766 - )); 5530 5530 + req.extensions_mut() 5531 5531 + .insert( 5532 5532 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "CreatePlaylist"), 5533 5533 + ); 4767 5534 self.inner.unary(req, path, codec).await 4768 5535 } 4769 5536 pub async fn insert_tracks( 4770 5537 &mut self, 4771 5538 request: impl tonic::IntoRequest<super::InsertTracksRequest>, 4772 4772 - ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status> 4773 4773 - { 4774 4774 - self.inner.ready().await.map_err(|e| { 4775 4775 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4776 4776 - })?; 5539 5539 + ) -> std::result::Result< 5540 5540 + tonic::Response<super::InsertTracksResponse>, 5541 5541 + tonic::Status, 5542 5542 + > { 5543 5543 + self.inner 5544 5544 + .ready() 5545 5545 + .await 5546 5546 + .map_err(|e| { 5547 5547 + tonic::Status::unknown( 5548 5548 + format!("Service was not ready: {}", e.into()), 5549 5549 + ) 5550 5550 + })?; 4777 5551 let codec = tonic::codec::ProstCodec::default(); 4778 5552 let path = http::uri::PathAndQuery::from_static( 4779 5553 "/rockbox.v1alpha1.PlaylistService/InsertTracks", 4780 5554 ); 4781 5555 let mut req = request.into_request(); 4782 4782 - req.extensions_mut().insert(GrpcMethod::new( 4783 4783 - "rockbox.v1alpha1.PlaylistService", 4784 4784 - "InsertTracks", 4785 4785 - )); 5556 5556 + req.extensions_mut() 5557 5557 + .insert( 5558 5558 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertTracks"), 5559 5559 + ); 4786 5560 self.inner.unary(req, path, codec).await 4787 5561 } 4788 5562 pub async fn insert_directory( 4789 5563 &mut self, 4790 5564 request: impl tonic::IntoRequest<super::InsertDirectoryRequest>, 4791 4791 - ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status> 4792 4792 - { 4793 4793 - self.inner.ready().await.map_err(|e| { 4794 4794 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4795 4795 - })?; 5565 5565 + ) -> std::result::Result< 5566 5566 + tonic::Response<super::InsertDirectoryResponse>, 5567 5567 + tonic::Status, 5568 5568 + > { 5569 5569 + self.inner 5570 5570 + .ready() 5571 5571 + .await 5572 5572 + .map_err(|e| { 5573 5573 + tonic::Status::unknown( 5574 5574 + format!("Service was not ready: {}", e.into()), 5575 5575 + ) 5576 5576 + })?; 4796 5577 let codec = tonic::codec::ProstCodec::default(); 4797 5578 let path = http::uri::PathAndQuery::from_static( 4798 5579 "/rockbox.v1alpha1.PlaylistService/InsertDirectory", 4799 5580 ); 4800 5581 let mut req = request.into_request(); 4801 4801 - req.extensions_mut().insert(GrpcMethod::new( 4802 4802 - "rockbox.v1alpha1.PlaylistService", 4803 4803 - "InsertDirectory", 4804 4804 - )); 5582 5582 + req.extensions_mut() 5583 5583 + .insert( 5584 5584 + GrpcMethod::new( 5585 5585 + "rockbox.v1alpha1.PlaylistService", 5586 5586 + "InsertDirectory", 5587 5587 + ), 5588 5588 + ); 4805 5589 self.inner.unary(req, path, codec).await 4806 5590 } 4807 5591 pub async fn insert_playlist( 4808 5592 &mut self, 4809 5593 request: impl tonic::IntoRequest<super::InsertPlaylistRequest>, 4810 4810 - ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status> 4811 4811 - { 4812 4812 - self.inner.ready().await.map_err(|e| { 4813 4813 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4814 4814 - })?; 5594 5594 + ) -> std::result::Result< 5595 5595 + tonic::Response<super::InsertPlaylistResponse>, 5596 5596 + tonic::Status, 5597 5597 + > { 5598 5598 + self.inner 5599 5599 + .ready() 5600 5600 + .await 5601 5601 + .map_err(|e| { 5602 5602 + tonic::Status::unknown( 5603 5603 + format!("Service was not ready: {}", e.into()), 5604 5604 + ) 5605 5605 + })?; 4815 5606 let codec = tonic::codec::ProstCodec::default(); 4816 5607 let path = http::uri::PathAndQuery::from_static( 4817 5608 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist", 4818 5609 ); 4819 5610 let mut req = request.into_request(); 4820 4820 - req.extensions_mut().insert(GrpcMethod::new( 4821 4821 - "rockbox.v1alpha1.PlaylistService", 4822 4822 - "InsertPlaylist", 4823 4823 - )); 5611 5611 + req.extensions_mut() 5612 5612 + .insert( 5613 5613 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertPlaylist"), 5614 5614 + ); 4824 5615 self.inner.unary(req, path, codec).await 4825 5616 } 4826 5617 pub async fn insert_album( 4827 5618 &mut self, 4828 5619 request: impl tonic::IntoRequest<super::InsertAlbumRequest>, 4829 4829 - ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status> 4830 4830 - { 4831 4831 - self.inner.ready().await.map_err(|e| { 4832 4832 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4833 4833 - })?; 5620 5620 + ) -> std::result::Result< 5621 5621 + tonic::Response<super::InsertAlbumResponse>, 5622 5622 + tonic::Status, 5623 5623 + > { 5624 5624 + self.inner 5625 5625 + .ready() 5626 5626 + .await 5627 5627 + .map_err(|e| { 5628 5628 + tonic::Status::unknown( 5629 5629 + format!("Service was not ready: {}", e.into()), 5630 5630 + ) 5631 5631 + })?; 4834 5632 let codec = tonic::codec::ProstCodec::default(); 4835 5633 let path = http::uri::PathAndQuery::from_static( 4836 5634 "/rockbox.v1alpha1.PlaylistService/InsertAlbum", 4837 5635 ); 4838 5636 let mut req = request.into_request(); 4839 4839 - req.extensions_mut().insert(GrpcMethod::new( 4840 4840 - "rockbox.v1alpha1.PlaylistService", 4841 4841 - "InsertAlbum", 4842 4842 - )); 5637 5637 + req.extensions_mut() 5638 5638 + .insert( 5639 5639 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertAlbum"), 5640 5640 + ); 4843 5641 self.inner.unary(req, path, codec).await 4844 5642 } 4845 5643 pub async fn insert_artist_tracks( 4846 5644 &mut self, 4847 5645 request: impl tonic::IntoRequest<super::InsertArtistTracksRequest>, 4848 4848 - ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status> 4849 4849 - { 4850 4850 - self.inner.ready().await.map_err(|e| { 4851 4851 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4852 4852 - })?; 5646 5646 + ) -> std::result::Result< 5647 5647 + tonic::Response<super::InsertArtistTracksResponse>, 5648 5648 + tonic::Status, 5649 5649 + > { 5650 5650 + self.inner 5651 5651 + .ready() 5652 5652 + .await 5653 5653 + .map_err(|e| { 5654 5654 + tonic::Status::unknown( 5655 5655 + format!("Service was not ready: {}", e.into()), 5656 5656 + ) 5657 5657 + })?; 4853 5658 let codec = tonic::codec::ProstCodec::default(); 4854 5659 let path = http::uri::PathAndQuery::from_static( 4855 5660 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks", 4856 5661 ); 4857 5662 let mut req = request.into_request(); 4858 4858 - req.extensions_mut().insert(GrpcMethod::new( 4859 4859 - "rockbox.v1alpha1.PlaylistService", 4860 4860 - "InsertArtistTracks", 4861 4861 - )); 5663 5663 + req.extensions_mut() 5664 5664 + .insert( 5665 5665 + GrpcMethod::new( 5666 5666 + "rockbox.v1alpha1.PlaylistService", 5667 5667 + "InsertArtistTracks", 5668 5668 + ), 5669 5669 + ); 4862 5670 self.inner.unary(req, path, codec).await 4863 5671 } 4864 5672 pub async fn shuffle_playlist( 4865 5673 &mut self, 4866 5674 request: impl tonic::IntoRequest<super::ShufflePlaylistRequest>, 4867 4867 - ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status> 4868 4868 - { 4869 4869 - self.inner.ready().await.map_err(|e| { 4870 4870 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4871 4871 - })?; 5675 5675 + ) -> std::result::Result< 5676 5676 + tonic::Response<super::ShufflePlaylistResponse>, 5677 5677 + tonic::Status, 5678 5678 + > { 5679 5679 + self.inner 5680 5680 + .ready() 5681 5681 + .await 5682 5682 + .map_err(|e| { 5683 5683 + tonic::Status::unknown( 5684 5684 + format!("Service was not ready: {}", e.into()), 5685 5685 + ) 5686 5686 + })?; 4872 5687 let codec = tonic::codec::ProstCodec::default(); 4873 5688 let path = http::uri::PathAndQuery::from_static( 4874 5689 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist", 4875 5690 ); 4876 5691 let mut req = request.into_request(); 4877 4877 - req.extensions_mut().insert(GrpcMethod::new( 4878 4878 - "rockbox.v1alpha1.PlaylistService", 4879 4879 - "ShufflePlaylist", 4880 4880 - )); 5692 5692 + req.extensions_mut() 5693 5693 + .insert( 5694 5694 + GrpcMethod::new( 5695 5695 + "rockbox.v1alpha1.PlaylistService", 5696 5696 + "ShufflePlaylist", 5697 5697 + ), 5698 5698 + ); 4881 5699 self.inner.unary(req, path, codec).await 4882 5700 } 4883 5701 } ··· 4889 5707 dead_code, 4890 5708 missing_docs, 4891 5709 clippy::wildcard_imports, 4892 4892 - clippy::let_unit_value 5710 5710 + clippy::let_unit_value, 4893 5711 )] 4894 5712 use tonic::codegen::*; 4895 5713 /// Generated trait containing gRPC methods that should be implemented for use with PlaylistServiceServer. ··· 4898 5716 async fn get_current( 4899 5717 &self, 4900 5718 request: tonic::Request<super::GetCurrentRequest>, 4901 4901 - ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status>; 5719 5719 + ) -> std::result::Result< 5720 5720 + tonic::Response<super::GetCurrentResponse>, 5721 5721 + tonic::Status, 5722 5722 + >; 4902 5723 async fn get_resume_info( 4903 5724 &self, 4904 5725 request: tonic::Request<super::GetResumeInfoRequest>, 4905 4905 - ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status>; 5726 5726 + ) -> std::result::Result< 5727 5727 + tonic::Response<super::GetResumeInfoResponse>, 5728 5728 + tonic::Status, 5729 5729 + >; 4906 5730 async fn get_track_info( 4907 5731 &self, 4908 5732 request: tonic::Request<super::GetTrackInfoRequest>, 4909 4909 - ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status>; 5733 5733 + ) -> std::result::Result< 5734 5734 + tonic::Response<super::GetTrackInfoResponse>, 5735 5735 + tonic::Status, 5736 5736 + >; 4910 5737 async fn get_first_index( 4911 5738 &self, 4912 5739 request: tonic::Request<super::GetFirstIndexRequest>, 4913 4913 - ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status>; 5740 5740 + ) -> std::result::Result< 5741 5741 + tonic::Response<super::GetFirstIndexResponse>, 5742 5742 + tonic::Status, 5743 5743 + >; 4914 5744 async fn get_display_index( 4915 5745 &self, 4916 5746 request: tonic::Request<super::GetDisplayIndexRequest>, 4917 4917 - ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>; 5747 5747 + ) -> std::result::Result< 5748 5748 + tonic::Response<super::GetDisplayIndexResponse>, 5749 5749 + tonic::Status, 5750 5750 + >; 4918 5751 async fn amount( 4919 5752 &self, 4920 5753 request: tonic::Request<super::AmountRequest>, ··· 4922 5755 async fn playlist_resume( 4923 5756 &self, 4924 5757 request: tonic::Request<super::PlaylistResumeRequest>, 4925 4925 - ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status>; 5758 5758 + ) -> std::result::Result< 5759 5759 + tonic::Response<super::PlaylistResumeResponse>, 5760 5760 + tonic::Status, 5761 5761 + >; 4926 5762 async fn resume_track( 4927 5763 &self, 4928 5764 request: tonic::Request<super::ResumeTrackRequest>, 4929 4929 - ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status>; 5765 5765 + ) -> std::result::Result< 5766 5766 + tonic::Response<super::ResumeTrackResponse>, 5767 5767 + tonic::Status, 5768 5768 + >; 4930 5769 async fn set_modified( 4931 5770 &self, 4932 5771 request: tonic::Request<super::SetModifiedRequest>, 4933 4933 - ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>; 5772 5772 + ) -> std::result::Result< 5773 5773 + tonic::Response<super::SetModifiedResponse>, 5774 5774 + tonic::Status, 5775 5775 + >; 4934 5776 async fn start( 4935 5777 &self, 4936 5778 request: tonic::Request<super::StartRequest>, ··· 4942 5784 async fn remove_all_tracks( 4943 5785 &self, 4944 5786 request: tonic::Request<super::RemoveAllTracksRequest>, 4945 4945 - ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status>; 5787 5787 + ) -> std::result::Result< 5788 5788 + tonic::Response<super::RemoveAllTracksResponse>, 5789 5789 + tonic::Status, 5790 5790 + >; 4946 5791 async fn remove_tracks( 4947 5792 &self, 4948 5793 request: tonic::Request<super::RemoveTracksRequest>, 4949 4949 - ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status>; 5794 5794 + ) -> std::result::Result< 5795 5795 + tonic::Response<super::RemoveTracksResponse>, 5796 5796 + tonic::Status, 5797 5797 + >; 4950 5798 async fn create_playlist( 4951 5799 &self, 4952 5800 request: tonic::Request<super::CreatePlaylistRequest>, 4953 4953 - ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status>; 5801 5801 + ) -> std::result::Result< 5802 5802 + tonic::Response<super::CreatePlaylistResponse>, 5803 5803 + tonic::Status, 5804 5804 + >; 4954 5805 async fn insert_tracks( 4955 5806 &self, 4956 5807 request: tonic::Request<super::InsertTracksRequest>, 4957 4957 - ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status>; 5808 5808 + ) -> std::result::Result< 5809 5809 + tonic::Response<super::InsertTracksResponse>, 5810 5810 + tonic::Status, 5811 5811 + >; 4958 5812 async fn insert_directory( 4959 5813 &self, 4960 5814 request: tonic::Request<super::InsertDirectoryRequest>, 4961 4961 - ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status>; 5815 5815 + ) -> std::result::Result< 5816 5816 + tonic::Response<super::InsertDirectoryResponse>, 5817 5817 + tonic::Status, 5818 5818 + >; 4962 5819 async fn insert_playlist( 4963 5820 &self, 4964 5821 request: tonic::Request<super::InsertPlaylistRequest>, 4965 4965 - ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status>; 5822 5822 + ) -> std::result::Result< 5823 5823 + tonic::Response<super::InsertPlaylistResponse>, 5824 5824 + tonic::Status, 5825 5825 + >; 4966 5826 async fn insert_album( 4967 5827 &self, 4968 5828 request: tonic::Request<super::InsertAlbumRequest>, 4969 4969 - ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>; 5829 5829 + ) -> std::result::Result< 5830 5830 + tonic::Response<super::InsertAlbumResponse>, 5831 5831 + tonic::Status, 5832 5832 + >; 4970 5833 async fn insert_artist_tracks( 4971 5834 &self, 4972 5835 request: tonic::Request<super::InsertArtistTracksRequest>, 4973 4973 - ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>; 5836 5836 + ) -> std::result::Result< 5837 5837 + tonic::Response<super::InsertArtistTracksResponse>, 5838 5838 + tonic::Status, 5839 5839 + >; 4974 5840 async fn shuffle_playlist( 4975 5841 &self, 4976 5842 request: tonic::Request<super::ShufflePlaylistRequest>, 4977 4977 - ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>; 5843 5843 + ) -> std::result::Result< 5844 5844 + tonic::Response<super::ShufflePlaylistResponse>, 5845 5845 + tonic::Status, 5846 5846 + >; 4978 5847 } 4979 5848 #[derive(Debug)] 4980 5849 pub struct PlaylistServiceServer<T> { ··· 4997 5866 max_encoding_message_size: None, 4998 5867 } 4999 5868 } 5000 5000 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 5869 5869 + pub fn with_interceptor<F>( 5870 5870 + inner: T, 5871 5871 + interceptor: F, 5872 5872 + ) -> InterceptedService<Self, F> 5001 5873 where 5002 5874 F: tonic::service::Interceptor, 5003 5875 { ··· 5052 5924 "/rockbox.v1alpha1.PlaylistService/GetCurrent" => { 5053 5925 #[allow(non_camel_case_types)] 5054 5926 struct GetCurrentSvc<T: PlaylistService>(pub Arc<T>); 5055 5055 - impl<T: PlaylistService> tonic::server::UnaryService<super::GetCurrentRequest> 5056 5056 - for GetCurrentSvc<T> 5057 5057 - { 5927 5927 + impl< 5928 5928 + T: PlaylistService, 5929 5929 + > tonic::server::UnaryService<super::GetCurrentRequest> 5930 5930 + for GetCurrentSvc<T> { 5058 5931 type Response = super::GetCurrentResponse; 5059 5059 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5932 5932 + type Future = BoxFuture< 5933 5933 + tonic::Response<Self::Response>, 5934 5934 + tonic::Status, 5935 5935 + >; 5060 5936 fn call( 5061 5937 &mut self, 5062 5938 request: tonic::Request<super::GetCurrentRequest>, ··· 5093 5969 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo" => { 5094 5970 #[allow(non_camel_case_types)] 5095 5971 struct GetResumeInfoSvc<T: PlaylistService>(pub Arc<T>); 5096 5096 - impl<T: PlaylistService> 5097 5097 - tonic::server::UnaryService<super::GetResumeInfoRequest> 5098 5098 - for GetResumeInfoSvc<T> 5099 5099 - { 5972 5972 + impl< 5973 5973 + T: PlaylistService, 5974 5974 + > tonic::server::UnaryService<super::GetResumeInfoRequest> 5975 5975 + for GetResumeInfoSvc<T> { 5100 5976 type Response = super::GetResumeInfoResponse; 5101 5101 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5977 5977 + type Future = BoxFuture< 5978 5978 + tonic::Response<Self::Response>, 5979 5979 + tonic::Status, 5980 5980 + >; 5102 5981 fn call( 5103 5982 &mut self, 5104 5983 request: tonic::Request<super::GetResumeInfoRequest>, 5105 5984 ) -> Self::Future { 5106 5985 let inner = Arc::clone(&self.0); 5107 5986 let fut = async move { 5108 5108 - <T as PlaylistService>::get_resume_info(&inner, request).await 5987 5987 + <T as PlaylistService>::get_resume_info(&inner, request) 5988 5988 + .await 5109 5989 }; 5110 5990 Box::pin(fut) 5111 5991 } ··· 5135 6015 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo" => { 5136 6016 #[allow(non_camel_case_types)] 5137 6017 struct GetTrackInfoSvc<T: PlaylistService>(pub Arc<T>); 5138 5138 - impl<T: PlaylistService> tonic::server::UnaryService<super::GetTrackInfoRequest> 5139 5139 - for GetTrackInfoSvc<T> 5140 5140 - { 6018 6018 + impl< 6019 6019 + T: PlaylistService, 6020 6020 + > tonic::server::UnaryService<super::GetTrackInfoRequest> 6021 6021 + for GetTrackInfoSvc<T> { 5141 6022 type Response = super::GetTrackInfoResponse; 5142 5142 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6023 6023 + type Future = BoxFuture< 6024 6024 + tonic::Response<Self::Response>, 6025 6025 + tonic::Status, 6026 6026 + >; 5143 6027 fn call( 5144 6028 &mut self, 5145 6029 request: tonic::Request<super::GetTrackInfoRequest>, 5146 6030 ) -> Self::Future { 5147 6031 let inner = Arc::clone(&self.0); 5148 6032 let fut = async move { 5149 5149 - <T as PlaylistService>::get_track_info(&inner, request).await 6033 6033 + <T as PlaylistService>::get_track_info(&inner, request) 6034 6034 + .await 5150 6035 }; 5151 6036 Box::pin(fut) 5152 6037 } ··· 5176 6061 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex" => { 5177 6062 #[allow(non_camel_case_types)] 5178 6063 struct GetFirstIndexSvc<T: PlaylistService>(pub Arc<T>); 5179 5179 - impl<T: PlaylistService> 5180 5180 - tonic::server::UnaryService<super::GetFirstIndexRequest> 5181 5181 - for GetFirstIndexSvc<T> 5182 5182 - { 6064 6064 + impl< 6065 6065 + T: PlaylistService, 6066 6066 + > tonic::server::UnaryService<super::GetFirstIndexRequest> 6067 6067 + for GetFirstIndexSvc<T> { 5183 6068 type Response = super::GetFirstIndexResponse; 5184 5184 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6069 6069 + type Future = BoxFuture< 6070 6070 + tonic::Response<Self::Response>, 6071 6071 + tonic::Status, 6072 6072 + >; 5185 6073 fn call( 5186 6074 &mut self, 5187 6075 request: tonic::Request<super::GetFirstIndexRequest>, 5188 6076 ) -> Self::Future { 5189 6077 let inner = Arc::clone(&self.0); 5190 6078 let fut = async move { 5191 5191 - <T as PlaylistService>::get_first_index(&inner, request).await 6079 6079 + <T as PlaylistService>::get_first_index(&inner, request) 6080 6080 + .await 5192 6081 }; 5193 6082 Box::pin(fut) 5194 6083 } ··· 5218 6107 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex" => { 5219 6108 #[allow(non_camel_case_types)] 5220 6109 struct GetDisplayIndexSvc<T: PlaylistService>(pub Arc<T>); 5221 5221 - impl<T: PlaylistService> 5222 5222 - tonic::server::UnaryService<super::GetDisplayIndexRequest> 5223 5223 - for GetDisplayIndexSvc<T> 5224 5224 - { 6110 6110 + impl< 6111 6111 + T: PlaylistService, 6112 6112 + > tonic::server::UnaryService<super::GetDisplayIndexRequest> 6113 6113 + for GetDisplayIndexSvc<T> { 5225 6114 type Response = super::GetDisplayIndexResponse; 5226 5226 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6115 6115 + type Future = BoxFuture< 6116 6116 + tonic::Response<Self::Response>, 6117 6117 + tonic::Status, 6118 6118 + >; 5227 6119 fn call( 5228 6120 &mut self, 5229 6121 request: tonic::Request<super::GetDisplayIndexRequest>, 5230 6122 ) -> Self::Future { 5231 6123 let inner = Arc::clone(&self.0); 5232 6124 let fut = async move { 5233 5233 - <T as PlaylistService>::get_display_index(&inner, request).await 6125 6125 + <T as PlaylistService>::get_display_index(&inner, request) 6126 6126 + .await 5234 6127 }; 5235 6128 Box::pin(fut) 5236 6129 } ··· 5260 6153 "/rockbox.v1alpha1.PlaylistService/Amount" => { 5261 6154 #[allow(non_camel_case_types)] 5262 6155 struct AmountSvc<T: PlaylistService>(pub Arc<T>); 5263 5263 - impl<T: PlaylistService> tonic::server::UnaryService<super::AmountRequest> for AmountSvc<T> { 6156 6156 + impl< 6157 6157 + T: PlaylistService, 6158 6158 + > tonic::server::UnaryService<super::AmountRequest> 6159 6159 + for AmountSvc<T> { 5264 6160 type Response = super::AmountResponse; 5265 5265 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6161 6161 + type Future = BoxFuture< 6162 6162 + tonic::Response<Self::Response>, 6163 6163 + tonic::Status, 6164 6164 + >; 5266 6165 fn call( 5267 6166 &mut self, 5268 6167 request: tonic::Request<super::AmountRequest>, ··· 5299 6198 "/rockbox.v1alpha1.PlaylistService/PlaylistResume" => { 5300 6199 #[allow(non_camel_case_types)] 5301 6200 struct PlaylistResumeSvc<T: PlaylistService>(pub Arc<T>); 5302 5302 - impl<T: PlaylistService> 5303 5303 - tonic::server::UnaryService<super::PlaylistResumeRequest> 5304 5304 - for PlaylistResumeSvc<T> 5305 5305 - { 6201 6201 + impl< 6202 6202 + T: PlaylistService, 6203 6203 + > tonic::server::UnaryService<super::PlaylistResumeRequest> 6204 6204 + for PlaylistResumeSvc<T> { 5306 6205 type Response = super::PlaylistResumeResponse; 5307 5307 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6206 6206 + type Future = BoxFuture< 6207 6207 + tonic::Response<Self::Response>, 6208 6208 + tonic::Status, 6209 6209 + >; 5308 6210 fn call( 5309 6211 &mut self, 5310 6212 request: tonic::Request<super::PlaylistResumeRequest>, 5311 6213 ) -> Self::Future { 5312 6214 let inner = Arc::clone(&self.0); 5313 6215 let fut = async move { 5314 5314 - <T as PlaylistService>::playlist_resume(&inner, request).await 6216 6216 + <T as PlaylistService>::playlist_resume(&inner, request) 6217 6217 + .await 5315 6218 }; 5316 6219 Box::pin(fut) 5317 6220 } ··· 5341 6244 "/rockbox.v1alpha1.PlaylistService/ResumeTrack" => { 5342 6245 #[allow(non_camel_case_types)] 5343 6246 struct ResumeTrackSvc<T: PlaylistService>(pub Arc<T>); 5344 5344 - impl<T: PlaylistService> tonic::server::UnaryService<super::ResumeTrackRequest> 5345 5345 - for ResumeTrackSvc<T> 5346 5346 - { 6247 6247 + impl< 6248 6248 + T: PlaylistService, 6249 6249 + > tonic::server::UnaryService<super::ResumeTrackRequest> 6250 6250 + for ResumeTrackSvc<T> { 5347 6251 type Response = super::ResumeTrackResponse; 5348 5348 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6252 6252 + type Future = BoxFuture< 6253 6253 + tonic::Response<Self::Response>, 6254 6254 + tonic::Status, 6255 6255 + >; 5349 6256 fn call( 5350 6257 &mut self, 5351 6258 request: tonic::Request<super::ResumeTrackRequest>, ··· 5382 6289 "/rockbox.v1alpha1.PlaylistService/SetModified" => { 5383 6290 #[allow(non_camel_case_types)] 5384 6291 struct SetModifiedSvc<T: PlaylistService>(pub Arc<T>); 5385 5385 - impl<T: PlaylistService> tonic::server::UnaryService<super::SetModifiedRequest> 5386 5386 - for SetModifiedSvc<T> 5387 5387 - { 6292 6292 + impl< 6293 6293 + T: PlaylistService, 6294 6294 + > tonic::server::UnaryService<super::SetModifiedRequest> 6295 6295 + for SetModifiedSvc<T> { 5388 6296 type Response = super::SetModifiedResponse; 5389 5389 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6297 6297 + type Future = BoxFuture< 6298 6298 + tonic::Response<Self::Response>, 6299 6299 + tonic::Status, 6300 6300 + >; 5390 6301 fn call( 5391 6302 &mut self, 5392 6303 request: tonic::Request<super::SetModifiedRequest>, ··· 5423 6334 "/rockbox.v1alpha1.PlaylistService/Start" => { 5424 6335 #[allow(non_camel_case_types)] 5425 6336 struct StartSvc<T: PlaylistService>(pub Arc<T>); 5426 5426 - impl<T: PlaylistService> tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 6337 6337 + impl< 6338 6338 + T: PlaylistService, 6339 6339 + > tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 5427 6340 type Response = super::StartResponse; 5428 5428 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6341 6341 + type Future = BoxFuture< 6342 6342 + tonic::Response<Self::Response>, 6343 6343 + tonic::Status, 6344 6344 + >; 5429 6345 fn call( 5430 6346 &mut self, 5431 6347 request: tonic::Request<super::StartRequest>, 5432 6348 ) -> Self::Future { 5433 6349 let inner = Arc::clone(&self.0); 5434 5434 - let fut = 5435 5435 - async move { <T as PlaylistService>::start(&inner, request).await }; 6350 6350 + let fut = async move { 6351 6351 + <T as PlaylistService>::start(&inner, request).await 6352 6352 + }; 5436 6353 Box::pin(fut) 5437 6354 } 5438 6355 } ··· 5461 6378 "/rockbox.v1alpha1.PlaylistService/Sync" => { 5462 6379 #[allow(non_camel_case_types)] 5463 6380 struct SyncSvc<T: PlaylistService>(pub Arc<T>); 5464 5464 - impl<T: PlaylistService> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 6381 6381 + impl< 6382 6382 + T: PlaylistService, 6383 6383 + > tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 5465 6384 type Response = super::SyncResponse; 5466 5466 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6385 6385 + type Future = BoxFuture< 6386 6386 + tonic::Response<Self::Response>, 6387 6387 + tonic::Status, 6388 6388 + >; 5467 6389 fn call( 5468 6390 &mut self, 5469 6391 request: tonic::Request<super::SyncRequest>, 5470 6392 ) -> Self::Future { 5471 6393 let inner = Arc::clone(&self.0); 5472 5472 - let fut = 5473 5473 - async move { <T as PlaylistService>::sync(&inner, request).await }; 6394 6394 + let fut = async move { 6395 6395 + <T as PlaylistService>::sync(&inner, request).await 6396 6396 + }; 5474 6397 Box::pin(fut) 5475 6398 } 5476 6399 } ··· 5499 6422 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks" => { 5500 6423 #[allow(non_camel_case_types)] 5501 6424 struct RemoveAllTracksSvc<T: PlaylistService>(pub Arc<T>); 5502 5502 - impl<T: PlaylistService> 5503 5503 - tonic::server::UnaryService<super::RemoveAllTracksRequest> 5504 5504 - for RemoveAllTracksSvc<T> 5505 5505 - { 6425 6425 + impl< 6426 6426 + T: PlaylistService, 6427 6427 + > tonic::server::UnaryService<super::RemoveAllTracksRequest> 6428 6428 + for RemoveAllTracksSvc<T> { 5506 6429 type Response = super::RemoveAllTracksResponse; 5507 5507 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6430 6430 + type Future = BoxFuture< 6431 6431 + tonic::Response<Self::Response>, 6432 6432 + tonic::Status, 6433 6433 + >; 5508 6434 fn call( 5509 6435 &mut self, 5510 6436 request: tonic::Request<super::RemoveAllTracksRequest>, 5511 6437 ) -> Self::Future { 5512 6438 let inner = Arc::clone(&self.0); 5513 6439 let fut = async move { 5514 5514 - <T as PlaylistService>::remove_all_tracks(&inner, request).await 6440 6440 + <T as PlaylistService>::remove_all_tracks(&inner, request) 6441 6441 + .await 5515 6442 }; 5516 6443 Box::pin(fut) 5517 6444 } ··· 5541 6468 "/rockbox.v1alpha1.PlaylistService/RemoveTracks" => { 5542 6469 #[allow(non_camel_case_types)] 5543 6470 struct RemoveTracksSvc<T: PlaylistService>(pub Arc<T>); 5544 5544 - impl<T: PlaylistService> tonic::server::UnaryService<super::RemoveTracksRequest> 5545 5545 - for RemoveTracksSvc<T> 5546 5546 - { 6471 6471 + impl< 6472 6472 + T: PlaylistService, 6473 6473 + > tonic::server::UnaryService<super::RemoveTracksRequest> 6474 6474 + for RemoveTracksSvc<T> { 5547 6475 type Response = super::RemoveTracksResponse; 5548 5548 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6476 6476 + type Future = BoxFuture< 6477 6477 + tonic::Response<Self::Response>, 6478 6478 + tonic::Status, 6479 6479 + >; 5549 6480 fn call( 5550 6481 &mut self, 5551 6482 request: tonic::Request<super::RemoveTracksRequest>, ··· 5582 6513 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist" => { 5583 6514 #[allow(non_camel_case_types)] 5584 6515 struct CreatePlaylistSvc<T: PlaylistService>(pub Arc<T>); 5585 5585 - impl<T: PlaylistService> 5586 5586 - tonic::server::UnaryService<super::CreatePlaylistRequest> 5587 5587 - for CreatePlaylistSvc<T> 5588 5588 - { 6516 6516 + impl< 6517 6517 + T: PlaylistService, 6518 6518 + > tonic::server::UnaryService<super::CreatePlaylistRequest> 6519 6519 + for CreatePlaylistSvc<T> { 5589 6520 type Response = super::CreatePlaylistResponse; 5590 5590 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6521 6521 + type Future = BoxFuture< 6522 6522 + tonic::Response<Self::Response>, 6523 6523 + tonic::Status, 6524 6524 + >; 5591 6525 fn call( 5592 6526 &mut self, 5593 6527 request: tonic::Request<super::CreatePlaylistRequest>, 5594 6528 ) -> Self::Future { 5595 6529 let inner = Arc::clone(&self.0); 5596 6530 let fut = async move { 5597 5597 - <T as PlaylistService>::create_playlist(&inner, request).await 6531 6531 + <T as PlaylistService>::create_playlist(&inner, request) 6532 6532 + .await 5598 6533 }; 5599 6534 Box::pin(fut) 5600 6535 } ··· 5624 6559 "/rockbox.v1alpha1.PlaylistService/InsertTracks" => { 5625 6560 #[allow(non_camel_case_types)] 5626 6561 struct InsertTracksSvc<T: PlaylistService>(pub Arc<T>); 5627 5627 - impl<T: PlaylistService> tonic::server::UnaryService<super::InsertTracksRequest> 5628 5628 - for InsertTracksSvc<T> 5629 5629 - { 6562 6562 + impl< 6563 6563 + T: PlaylistService, 6564 6564 + > tonic::server::UnaryService<super::InsertTracksRequest> 6565 6565 + for InsertTracksSvc<T> { 5630 6566 type Response = super::InsertTracksResponse; 5631 5631 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6567 6567 + type Future = BoxFuture< 6568 6568 + tonic::Response<Self::Response>, 6569 6569 + tonic::Status, 6570 6570 + >; 5632 6571 fn call( 5633 6572 &mut self, 5634 6573 request: tonic::Request<super::InsertTracksRequest>, ··· 5665 6604 "/rockbox.v1alpha1.PlaylistService/InsertDirectory" => { 5666 6605 #[allow(non_camel_case_types)] 5667 6606 struct InsertDirectorySvc<T: PlaylistService>(pub Arc<T>); 5668 5668 - impl<T: PlaylistService> 5669 5669 - tonic::server::UnaryService<super::InsertDirectoryRequest> 5670 5670 - for InsertDirectorySvc<T> 5671 5671 - { 6607 6607 + impl< 6608 6608 + T: PlaylistService, 6609 6609 + > tonic::server::UnaryService<super::InsertDirectoryRequest> 6610 6610 + for InsertDirectorySvc<T> { 5672 6611 type Response = super::InsertDirectoryResponse; 5673 5673 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6612 6612 + type Future = BoxFuture< 6613 6613 + tonic::Response<Self::Response>, 6614 6614 + tonic::Status, 6615 6615 + >; 5674 6616 fn call( 5675 6617 &mut self, 5676 6618 request: tonic::Request<super::InsertDirectoryRequest>, 5677 6619 ) -> Self::Future { 5678 6620 let inner = Arc::clone(&self.0); 5679 6621 let fut = async move { 5680 5680 - <T as PlaylistService>::insert_directory(&inner, request).await 6622 6622 + <T as PlaylistService>::insert_directory(&inner, request) 6623 6623 + .await 5681 6624 }; 5682 6625 Box::pin(fut) 5683 6626 } ··· 5707 6650 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist" => { 5708 6651 #[allow(non_camel_case_types)] 5709 6652 struct InsertPlaylistSvc<T: PlaylistService>(pub Arc<T>); 5710 5710 - impl<T: PlaylistService> 5711 5711 - tonic::server::UnaryService<super::InsertPlaylistRequest> 5712 5712 - for InsertPlaylistSvc<T> 5713 5713 - { 6653 6653 + impl< 6654 6654 + T: PlaylistService, 6655 6655 + > tonic::server::UnaryService<super::InsertPlaylistRequest> 6656 6656 + for InsertPlaylistSvc<T> { 5714 6657 type Response = super::InsertPlaylistResponse; 5715 5715 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6658 6658 + type Future = BoxFuture< 6659 6659 + tonic::Response<Self::Response>, 6660 6660 + tonic::Status, 6661 6661 + >; 5716 6662 fn call( 5717 6663 &mut self, 5718 6664 request: tonic::Request<super::InsertPlaylistRequest>, 5719 6665 ) -> Self::Future { 5720 6666 let inner = Arc::clone(&self.0); 5721 6667 let fut = async move { 5722 5722 - <T as PlaylistService>::insert_playlist(&inner, request).await 6668 6668 + <T as PlaylistService>::insert_playlist(&inner, request) 6669 6669 + .await 5723 6670 }; 5724 6671 Box::pin(fut) 5725 6672 } ··· 5749 6696 "/rockbox.v1alpha1.PlaylistService/InsertAlbum" => { 5750 6697 #[allow(non_camel_case_types)] 5751 6698 struct InsertAlbumSvc<T: PlaylistService>(pub Arc<T>); 5752 5752 - impl<T: PlaylistService> tonic::server::UnaryService<super::InsertAlbumRequest> 5753 5753 - for InsertAlbumSvc<T> 5754 5754 - { 6699 6699 + impl< 6700 6700 + T: PlaylistService, 6701 6701 + > tonic::server::UnaryService<super::InsertAlbumRequest> 6702 6702 + for InsertAlbumSvc<T> { 5755 6703 type Response = super::InsertAlbumResponse; 5756 5756 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6704 6704 + type Future = BoxFuture< 6705 6705 + tonic::Response<Self::Response>, 6706 6706 + tonic::Status, 6707 6707 + >; 5757 6708 fn call( 5758 6709 &mut self, 5759 6710 request: tonic::Request<super::InsertAlbumRequest>, ··· 5790 6741 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks" => { 5791 6742 #[allow(non_camel_case_types)] 5792 6743 struct InsertArtistTracksSvc<T: PlaylistService>(pub Arc<T>); 5793 5793 - impl<T: PlaylistService> 5794 5794 - tonic::server::UnaryService<super::InsertArtistTracksRequest> 5795 5795 - for InsertArtistTracksSvc<T> 5796 5796 - { 6744 6744 + impl< 6745 6745 + T: PlaylistService, 6746 6746 + > tonic::server::UnaryService<super::InsertArtistTracksRequest> 6747 6747 + for InsertArtistTracksSvc<T> { 5797 6748 type Response = super::InsertArtistTracksResponse; 5798 5798 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6749 6749 + type Future = BoxFuture< 6750 6750 + tonic::Response<Self::Response>, 6751 6751 + tonic::Status, 6752 6752 + >; 5799 6753 fn call( 5800 6754 &mut self, 5801 6755 request: tonic::Request<super::InsertArtistTracksRequest>, 5802 6756 ) -> Self::Future { 5803 6757 let inner = Arc::clone(&self.0); 5804 6758 let fut = async move { 5805 5805 - <T as PlaylistService>::insert_artist_tracks(&inner, request).await 6759 6759 + <T as PlaylistService>::insert_artist_tracks( 6760 6760 + &inner, 6761 6761 + request, 6762 6762 + ) 6763 6763 + .await 5806 6764 }; 5807 6765 Box::pin(fut) 5808 6766 } ··· 5832 6790 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist" => { 5833 6791 #[allow(non_camel_case_types)] 5834 6792 struct ShufflePlaylistSvc<T: PlaylistService>(pub Arc<T>); 5835 5835 - impl<T: PlaylistService> 5836 5836 - tonic::server::UnaryService<super::ShufflePlaylistRequest> 5837 5837 - for ShufflePlaylistSvc<T> 5838 5838 - { 6793 6793 + impl< 6794 6794 + T: PlaylistService, 6795 6795 + > tonic::server::UnaryService<super::ShufflePlaylistRequest> 6796 6796 + for ShufflePlaylistSvc<T> { 5839 6797 type Response = super::ShufflePlaylistResponse; 5840 5840 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6798 6798 + type Future = BoxFuture< 6799 6799 + tonic::Response<Self::Response>, 6800 6800 + tonic::Status, 6801 6801 + >; 5841 6802 fn call( 5842 6803 &mut self, 5843 6804 request: tonic::Request<super::ShufflePlaylistRequest>, 5844 6805 ) -> Self::Future { 5845 6806 let inner = Arc::clone(&self.0); 5846 6807 let fut = async move { 5847 5847 - <T as PlaylistService>::shuffle_playlist(&inner, request).await 6808 6808 + <T as PlaylistService>::shuffle_playlist(&inner, request) 6809 6809 + .await 5848 6810 }; 5849 6811 Box::pin(fut) 5850 6812 } ··· 5871 6833 }; 5872 6834 Box::pin(fut) 5873 6835 } 5874 5874 - _ => Box::pin(async move { 5875 5875 - let mut response = http::Response::new(empty_body()); 5876 5876 - let headers = response.headers_mut(); 5877 5877 - headers.insert( 5878 5878 - tonic::Status::GRPC_STATUS, 5879 5879 - (tonic::Code::Unimplemented as i32).into(), 5880 5880 - ); 5881 5881 - headers.insert( 5882 5882 - http::header::CONTENT_TYPE, 5883 5883 - tonic::metadata::GRPC_CONTENT_TYPE, 5884 5884 - ); 5885 5885 - Ok(response) 5886 5886 - }), 6836 6836 + _ => { 6837 6837 + Box::pin(async move { 6838 6838 + let mut response = http::Response::new(empty_body()); 6839 6839 + let headers = response.headers_mut(); 6840 6840 + headers 6841 6841 + .insert( 6842 6842 + tonic::Status::GRPC_STATUS, 6843 6843 + (tonic::Code::Unimplemented as i32).into(), 6844 6844 + ); 6845 6845 + headers 6846 6846 + .insert( 6847 6847 + http::header::CONTENT_TYPE, 6848 6848 + tonic::metadata::GRPC_CONTENT_TYPE, 6849 6849 + ); 6850 6850 + Ok(response) 6851 6851 + }) 6852 6852 + } 5887 6853 } 5888 6854 } 5889 6855 } ··· 6391 7357 dead_code, 6392 7358 missing_docs, 6393 7359 clippy::wildcard_imports, 6394 6394 - clippy::let_unit_value 7360 7360 + clippy::let_unit_value, 6395 7361 )] 6396 6396 - use tonic::codegen::http::Uri; 6397 7362 use tonic::codegen::*; 7363 7363 + use tonic::codegen::http::Uri; 6398 7364 #[derive(Debug, Clone)] 6399 7365 pub struct SettingsServiceClient<T> { 6400 7366 inner: tonic::client::Grpc<T>, ··· 6438 7404 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 6439 7405 >, 6440 7406 >, 6441 6441 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 6442 6442 - Into<StdError> + std::marker::Send + std::marker::Sync, 7407 7407 + <T as tonic::codegen::Service< 7408 7408 + http::Request<tonic::body::BoxBody>, 7409 7409 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6443 7410 { 6444 7411 SettingsServiceClient::new(InterceptedService::new(inner, interceptor)) 6445 7412 } ··· 6477 7444 pub async fn get_settings_list( 6478 7445 &mut self, 6479 7446 request: impl tonic::IntoRequest<super::GetSettingsListRequest>, 6480 6480 - ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status> 6481 6481 - { 6482 6482 - self.inner.ready().await.map_err(|e| { 6483 6483 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6484 6484 - })?; 7447 7447 + ) -> std::result::Result< 7448 7448 + tonic::Response<super::GetSettingsListResponse>, 7449 7449 + tonic::Status, 7450 7450 + > { 7451 7451 + self.inner 7452 7452 + .ready() 7453 7453 + .await 7454 7454 + .map_err(|e| { 7455 7455 + tonic::Status::unknown( 7456 7456 + format!("Service was not ready: {}", e.into()), 7457 7457 + ) 7458 7458 + })?; 6485 7459 let codec = tonic::codec::ProstCodec::default(); 6486 7460 let path = http::uri::PathAndQuery::from_static( 6487 7461 "/rockbox.v1alpha1.SettingsService/GetSettingsList", 6488 7462 ); 6489 7463 let mut req = request.into_request(); 6490 6490 - req.extensions_mut().insert(GrpcMethod::new( 6491 6491 - "rockbox.v1alpha1.SettingsService", 6492 6492 - "GetSettingsList", 6493 6493 - )); 7464 7464 + req.extensions_mut() 7465 7465 + .insert( 7466 7466 + GrpcMethod::new( 7467 7467 + "rockbox.v1alpha1.SettingsService", 7468 7468 + "GetSettingsList", 7469 7469 + ), 7470 7470 + ); 6494 7471 self.inner.unary(req, path, codec).await 6495 7472 } 6496 7473 pub async fn get_global_settings( 6497 7474 &mut self, 6498 7475 request: impl tonic::IntoRequest<super::GetGlobalSettingsRequest>, 6499 6499 - ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status> 6500 6500 - { 6501 6501 - self.inner.ready().await.map_err(|e| { 6502 6502 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6503 6503 - })?; 7476 7476 + ) -> std::result::Result< 7477 7477 + tonic::Response<super::GetGlobalSettingsResponse>, 7478 7478 + tonic::Status, 7479 7479 + > { 7480 7480 + self.inner 7481 7481 + .ready() 7482 7482 + .await 7483 7483 + .map_err(|e| { 7484 7484 + tonic::Status::unknown( 7485 7485 + format!("Service was not ready: {}", e.into()), 7486 7486 + ) 7487 7487 + })?; 6504 7488 let codec = tonic::codec::ProstCodec::default(); 6505 7489 let path = http::uri::PathAndQuery::from_static( 6506 7490 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings", 6507 7491 ); 6508 7492 let mut req = request.into_request(); 6509 6509 - req.extensions_mut().insert(GrpcMethod::new( 6510 6510 - "rockbox.v1alpha1.SettingsService", 6511 6511 - "GetGlobalSettings", 6512 6512 - )); 7493 7493 + req.extensions_mut() 7494 7494 + .insert( 7495 7495 + GrpcMethod::new( 7496 7496 + "rockbox.v1alpha1.SettingsService", 7497 7497 + "GetGlobalSettings", 7498 7498 + ), 7499 7499 + ); 6513 7500 self.inner.unary(req, path, codec).await 6514 7501 } 6515 7502 pub async fn save_settings( 6516 7503 &mut self, 6517 7504 request: impl tonic::IntoRequest<super::SaveSettingsRequest>, 6518 6518 - ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status> 6519 6519 - { 6520 6520 - self.inner.ready().await.map_err(|e| { 6521 6521 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6522 6522 - })?; 7505 7505 + ) -> std::result::Result< 7506 7506 + tonic::Response<super::SaveSettingsResponse>, 7507 7507 + tonic::Status, 7508 7508 + > { 7509 7509 + self.inner 7510 7510 + .ready() 7511 7511 + .await 7512 7512 + .map_err(|e| { 7513 7513 + tonic::Status::unknown( 7514 7514 + format!("Service was not ready: {}", e.into()), 7515 7515 + ) 7516 7516 + })?; 6523 7517 let codec = tonic::codec::ProstCodec::default(); 6524 7518 let path = http::uri::PathAndQuery::from_static( 6525 7519 "/rockbox.v1alpha1.SettingsService/SaveSettings", 6526 7520 ); 6527 7521 let mut req = request.into_request(); 6528 6528 - req.extensions_mut().insert(GrpcMethod::new( 6529 6529 - "rockbox.v1alpha1.SettingsService", 6530 6530 - "SaveSettings", 6531 6531 - )); 7522 7522 + req.extensions_mut() 7523 7523 + .insert( 7524 7524 + GrpcMethod::new("rockbox.v1alpha1.SettingsService", "SaveSettings"), 7525 7525 + ); 6532 7526 self.inner.unary(req, path, codec).await 6533 7527 } 6534 7528 } ··· 6540 7534 dead_code, 6541 7535 missing_docs, 6542 7536 clippy::wildcard_imports, 6543 6543 - clippy::let_unit_value 7537 7537 + clippy::let_unit_value, 6544 7538 )] 6545 7539 use tonic::codegen::*; 6546 7540 /// Generated trait containing gRPC methods that should be implemented for use with SettingsServiceServer. ··· 6549 7543 async fn get_settings_list( 6550 7544 &self, 6551 7545 request: tonic::Request<super::GetSettingsListRequest>, 6552 6552 - ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status>; 7546 7546 + ) -> std::result::Result< 7547 7547 + tonic::Response<super::GetSettingsListResponse>, 7548 7548 + tonic::Status, 7549 7549 + >; 6553 7550 async fn get_global_settings( 6554 7551 &self, 6555 7552 request: tonic::Request<super::GetGlobalSettingsRequest>, 6556 6556 - ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status>; 7553 7553 + ) -> std::result::Result< 7554 7554 + tonic::Response<super::GetGlobalSettingsResponse>, 7555 7555 + tonic::Status, 7556 7556 + >; 6557 7557 async fn save_settings( 6558 7558 &self, 6559 7559 request: tonic::Request<super::SaveSettingsRequest>, 6560 6560 - ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>; 7560 7560 + ) -> std::result::Result< 7561 7561 + tonic::Response<super::SaveSettingsResponse>, 7562 7562 + tonic::Status, 7563 7563 + >; 6561 7564 } 6562 7565 #[derive(Debug)] 6563 7566 pub struct SettingsServiceServer<T> { ··· 6580 7583 max_encoding_message_size: None, 6581 7584 } 6582 7585 } 6583 6583 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 7586 7586 + pub fn with_interceptor<F>( 7587 7587 + inner: T, 7588 7588 + interceptor: F, 7589 7589 + ) -> InterceptedService<Self, F> 6584 7590 where 6585 7591 F: tonic::service::Interceptor, 6586 7592 { ··· 6635 7641 "/rockbox.v1alpha1.SettingsService/GetSettingsList" => { 6636 7642 #[allow(non_camel_case_types)] 6637 7643 struct GetSettingsListSvc<T: SettingsService>(pub Arc<T>); 6638 6638 - impl<T: SettingsService> 6639 6639 - tonic::server::UnaryService<super::GetSettingsListRequest> 6640 6640 - for GetSettingsListSvc<T> 6641 6641 - { 7644 7644 + impl< 7645 7645 + T: SettingsService, 7646 7646 + > tonic::server::UnaryService<super::GetSettingsListRequest> 7647 7647 + for GetSettingsListSvc<T> { 6642 7648 type Response = super::GetSettingsListResponse; 6643 6643 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7649 7649 + type Future = BoxFuture< 7650 7650 + tonic::Response<Self::Response>, 7651 7651 + tonic::Status, 7652 7652 + >; 6644 7653 fn call( 6645 7654 &mut self, 6646 7655 request: tonic::Request<super::GetSettingsListRequest>, 6647 7656 ) -> Self::Future { 6648 7657 let inner = Arc::clone(&self.0); 6649 7658 let fut = async move { 6650 6650 - <T as SettingsService>::get_settings_list(&inner, request).await 7659 7659 + <T as SettingsService>::get_settings_list(&inner, request) 7660 7660 + .await 6651 7661 }; 6652 7662 Box::pin(fut) 6653 7663 } ··· 6677 7687 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings" => { 6678 7688 #[allow(non_camel_case_types)] 6679 7689 struct GetGlobalSettingsSvc<T: SettingsService>(pub Arc<T>); 6680 6680 - impl<T: SettingsService> 6681 6681 - tonic::server::UnaryService<super::GetGlobalSettingsRequest> 6682 6682 - for GetGlobalSettingsSvc<T> 6683 6683 - { 7690 7690 + impl< 7691 7691 + T: SettingsService, 7692 7692 + > tonic::server::UnaryService<super::GetGlobalSettingsRequest> 7693 7693 + for GetGlobalSettingsSvc<T> { 6684 7694 type Response = super::GetGlobalSettingsResponse; 6685 6685 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7695 7695 + type Future = BoxFuture< 7696 7696 + tonic::Response<Self::Response>, 7697 7697 + tonic::Status, 7698 7698 + >; 6686 7699 fn call( 6687 7700 &mut self, 6688 7701 request: tonic::Request<super::GetGlobalSettingsRequest>, 6689 7702 ) -> Self::Future { 6690 7703 let inner = Arc::clone(&self.0); 6691 7704 let fut = async move { 6692 6692 - <T as SettingsService>::get_global_settings(&inner, request).await 7705 7705 + <T as SettingsService>::get_global_settings(&inner, request) 7706 7706 + .await 6693 7707 }; 6694 7708 Box::pin(fut) 6695 7709 } ··· 6719 7733 "/rockbox.v1alpha1.SettingsService/SaveSettings" => { 6720 7734 #[allow(non_camel_case_types)] 6721 7735 struct SaveSettingsSvc<T: SettingsService>(pub Arc<T>); 6722 6722 - impl<T: SettingsService> tonic::server::UnaryService<super::SaveSettingsRequest> 6723 6723 - for SaveSettingsSvc<T> 6724 6724 - { 7736 7736 + impl< 7737 7737 + T: SettingsService, 7738 7738 + > tonic::server::UnaryService<super::SaveSettingsRequest> 7739 7739 + for SaveSettingsSvc<T> { 6725 7740 type Response = super::SaveSettingsResponse; 6726 6726 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7741 7741 + type Future = BoxFuture< 7742 7742 + tonic::Response<Self::Response>, 7743 7743 + tonic::Status, 7744 7744 + >; 6727 7745 fn call( 6728 7746 &mut self, 6729 7747 request: tonic::Request<super::SaveSettingsRequest>, ··· 6757 7775 }; 6758 7776 Box::pin(fut) 6759 7777 } 6760 6760 - _ => Box::pin(async move { 6761 6761 - let mut response = http::Response::new(empty_body()); 6762 6762 - let headers = response.headers_mut(); 6763 6763 - headers.insert( 6764 6764 - tonic::Status::GRPC_STATUS, 6765 6765 - (tonic::Code::Unimplemented as i32).into(), 6766 6766 - ); 6767 6767 - headers.insert( 6768 6768 - http::header::CONTENT_TYPE, 6769 6769 - tonic::metadata::GRPC_CONTENT_TYPE, 6770 6770 - ); 6771 6771 - Ok(response) 6772 6772 - }), 7778 7778 + _ => { 7779 7779 + Box::pin(async move { 7780 7780 + let mut response = http::Response::new(empty_body()); 7781 7781 + let headers = response.headers_mut(); 7782 7782 + headers 7783 7783 + .insert( 7784 7784 + tonic::Status::GRPC_STATUS, 7785 7785 + (tonic::Code::Unimplemented as i32).into(), 7786 7786 + ); 7787 7787 + headers 7788 7788 + .insert( 7789 7789 + http::header::CONTENT_TYPE, 7790 7790 + tonic::metadata::GRPC_CONTENT_TYPE, 7791 7791 + ); 7792 7792 + Ok(response) 7793 7793 + }) 7794 7794 + } 6773 7795 } 6774 7796 } 6775 7797 } ··· 6927 7949 dead_code, 6928 7950 missing_docs, 6929 7951 clippy::wildcard_imports, 6930 6930 - clippy::let_unit_value 7952 7952 + clippy::let_unit_value, 6931 7953 )] 6932 6932 - use tonic::codegen::http::Uri; 6933 7954 use tonic::codegen::*; 7955 7955 + use tonic::codegen::http::Uri; 6934 7956 #[derive(Debug, Clone)] 6935 7957 pub struct SoundServiceClient<T> { 6936 7958 inner: tonic::client::Grpc<T>, ··· 6974 7996 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 6975 7997 >, 6976 7998 >, 6977 6977 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 6978 6978 - Into<StdError> + std::marker::Send + std::marker::Sync, 7999 7999 + <T as tonic::codegen::Service< 8000 8000 + http::Request<tonic::body::BoxBody>, 8001 8001 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6979 8002 { 6980 8003 SoundServiceClient::new(InterceptedService::new(inner, interceptor)) 6981 8004 } ··· 7013 8036 pub async fn adjust_volume( 7014 8037 &mut self, 7015 8038 request: impl tonic::IntoRequest<super::AdjustVolumeRequest>, 7016 7016 - ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status> 7017 7017 - { 7018 7018 - self.inner.ready().await.map_err(|e| { 7019 7019 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7020 7020 - })?; 8039 8039 + ) -> std::result::Result< 8040 8040 + tonic::Response<super::AdjustVolumeResponse>, 8041 8041 + tonic::Status, 8042 8042 + > { 8043 8043 + self.inner 8044 8044 + .ready() 8045 8045 + .await 8046 8046 + .map_err(|e| { 8047 8047 + tonic::Status::unknown( 8048 8048 + format!("Service was not ready: {}", e.into()), 8049 8049 + ) 8050 8050 + })?; 7021 8051 let codec = tonic::codec::ProstCodec::default(); 7022 7022 - let path = 7023 7023 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/AdjustVolume"); 8052 8052 + let path = http::uri::PathAndQuery::from_static( 8053 8053 + "/rockbox.v1alpha1.SoundService/AdjustVolume", 8054 8054 + ); 7024 8055 let mut req = request.into_request(); 7025 7025 - req.extensions_mut().insert(GrpcMethod::new( 7026 7026 - "rockbox.v1alpha1.SoundService", 7027 7027 - "AdjustVolume", 7028 7028 - )); 8056 8056 + req.extensions_mut() 8057 8057 + .insert( 8058 8058 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "AdjustVolume"), 8059 8059 + ); 7029 8060 self.inner.unary(req, path, codec).await 7030 8061 } 7031 8062 pub async fn sound_set( 7032 8063 &mut self, 7033 8064 request: impl tonic::IntoRequest<super::SoundSetRequest>, 7034 7034 - ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status> { 7035 7035 - self.inner.ready().await.map_err(|e| { 7036 7036 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7037 7037 - })?; 8065 8065 + ) -> std::result::Result< 8066 8066 + tonic::Response<super::SoundSetResponse>, 8067 8067 + tonic::Status, 8068 8068 + > { 8069 8069 + self.inner 8070 8070 + .ready() 8071 8071 + .await 8072 8072 + .map_err(|e| { 8073 8073 + tonic::Status::unknown( 8074 8074 + format!("Service was not ready: {}", e.into()), 8075 8075 + ) 8076 8076 + })?; 7038 8077 let codec = tonic::codec::ProstCodec::default(); 7039 7039 - let path = 7040 7040 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundSet"); 8078 8078 + let path = http::uri::PathAndQuery::from_static( 8079 8079 + "/rockbox.v1alpha1.SoundService/SoundSet", 8080 8080 + ); 7041 8081 let mut req = request.into_request(); 7042 8082 req.extensions_mut() 7043 8083 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundSet")); ··· 7046 8086 pub async fn sound_current( 7047 8087 &mut self, 7048 8088 request: impl tonic::IntoRequest<super::SoundCurrentRequest>, 7049 7049 - ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status> 7050 7050 - { 7051 7051 - self.inner.ready().await.map_err(|e| { 7052 7052 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7053 7053 - })?; 8089 8089 + ) -> std::result::Result< 8090 8090 + tonic::Response<super::SoundCurrentResponse>, 8091 8091 + tonic::Status, 8092 8092 + > { 8093 8093 + self.inner 8094 8094 + .ready() 8095 8095 + .await 8096 8096 + .map_err(|e| { 8097 8097 + tonic::Status::unknown( 8098 8098 + format!("Service was not ready: {}", e.into()), 8099 8099 + ) 8100 8100 + })?; 7054 8101 let codec = tonic::codec::ProstCodec::default(); 7055 7055 - let path = 7056 7056 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundCurrent"); 8102 8102 + let path = http::uri::PathAndQuery::from_static( 8103 8103 + "/rockbox.v1alpha1.SoundService/SoundCurrent", 8104 8104 + ); 7057 8105 let mut req = request.into_request(); 7058 7058 - req.extensions_mut().insert(GrpcMethod::new( 7059 7059 - "rockbox.v1alpha1.SoundService", 7060 7060 - "SoundCurrent", 7061 7061 - )); 8106 8106 + req.extensions_mut() 8107 8107 + .insert( 8108 8108 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundCurrent"), 8109 8109 + ); 7062 8110 self.inner.unary(req, path, codec).await 7063 8111 } 7064 8112 pub async fn sound_default( 7065 8113 &mut self, 7066 8114 request: impl tonic::IntoRequest<super::SoundDefaultRequest>, 7067 7067 - ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status> 7068 7068 - { 7069 7069 - self.inner.ready().await.map_err(|e| { 7070 7070 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7071 7071 - })?; 8115 8115 + ) -> std::result::Result< 8116 8116 + tonic::Response<super::SoundDefaultResponse>, 8117 8117 + tonic::Status, 8118 8118 + > { 8119 8119 + self.inner 8120 8120 + .ready() 8121 8121 + .await 8122 8122 + .map_err(|e| { 8123 8123 + tonic::Status::unknown( 8124 8124 + format!("Service was not ready: {}", e.into()), 8125 8125 + ) 8126 8126 + })?; 7072 8127 let codec = tonic::codec::ProstCodec::default(); 7073 7073 - let path = 7074 7074 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundDefault"); 8128 8128 + let path = http::uri::PathAndQuery::from_static( 8129 8129 + "/rockbox.v1alpha1.SoundService/SoundDefault", 8130 8130 + ); 7075 8131 let mut req = request.into_request(); 7076 7076 - req.extensions_mut().insert(GrpcMethod::new( 7077 7077 - "rockbox.v1alpha1.SoundService", 7078 7078 - "SoundDefault", 7079 7079 - )); 8132 8132 + req.extensions_mut() 8133 8133 + .insert( 8134 8134 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundDefault"), 8135 8135 + ); 7080 8136 self.inner.unary(req, path, codec).await 7081 8137 } 7082 8138 pub async fn sound_min( 7083 8139 &mut self, 7084 8140 request: impl tonic::IntoRequest<super::SoundMinRequest>, 7085 7085 - ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status> { 7086 7086 - self.inner.ready().await.map_err(|e| { 7087 7087 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7088 7088 - })?; 8141 8141 + ) -> std::result::Result< 8142 8142 + tonic::Response<super::SoundMinResponse>, 8143 8143 + tonic::Status, 8144 8144 + > { 8145 8145 + self.inner 8146 8146 + .ready() 8147 8147 + .await 8148 8148 + .map_err(|e| { 8149 8149 + tonic::Status::unknown( 8150 8150 + format!("Service was not ready: {}", e.into()), 8151 8151 + ) 8152 8152 + })?; 7089 8153 let codec = tonic::codec::ProstCodec::default(); 7090 7090 - let path = 7091 7091 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMin"); 8154 8154 + let path = http::uri::PathAndQuery::from_static( 8155 8155 + "/rockbox.v1alpha1.SoundService/SoundMin", 8156 8156 + ); 7092 8157 let mut req = request.into_request(); 7093 8158 req.extensions_mut() 7094 8159 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMin")); ··· 7097 8162 pub async fn sound_max( 7098 8163 &mut self, 7099 8164 request: impl tonic::IntoRequest<super::SoundMaxRequest>, 7100 7100 - ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status> { 7101 7101 - self.inner.ready().await.map_err(|e| { 7102 7102 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7103 7103 - })?; 8165 8165 + ) -> std::result::Result< 8166 8166 + tonic::Response<super::SoundMaxResponse>, 8167 8167 + tonic::Status, 8168 8168 + > { 8169 8169 + self.inner 8170 8170 + .ready() 8171 8171 + .await 8172 8172 + .map_err(|e| { 8173 8173 + tonic::Status::unknown( 8174 8174 + format!("Service was not ready: {}", e.into()), 8175 8175 + ) 8176 8176 + })?; 7104 8177 let codec = tonic::codec::ProstCodec::default(); 7105 7105 - let path = 7106 7106 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMax"); 8178 8178 + let path = http::uri::PathAndQuery::from_static( 8179 8179 + "/rockbox.v1alpha1.SoundService/SoundMax", 8180 8180 + ); 7107 8181 let mut req = request.into_request(); 7108 8182 req.extensions_mut() 7109 8183 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMax")); ··· 7112 8186 pub async fn sound_unit( 7113 8187 &mut self, 7114 8188 request: impl tonic::IntoRequest<super::SoundUnitRequest>, 7115 7115 - ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status> { 7116 7116 - self.inner.ready().await.map_err(|e| { 7117 7117 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7118 7118 - })?; 8189 8189 + ) -> std::result::Result< 8190 8190 + tonic::Response<super::SoundUnitResponse>, 8191 8191 + tonic::Status, 8192 8192 + > { 8193 8193 + self.inner 8194 8194 + .ready() 8195 8195 + .await 8196 8196 + .map_err(|e| { 8197 8197 + tonic::Status::unknown( 8198 8198 + format!("Service was not ready: {}", e.into()), 8199 8199 + ) 8200 8200 + })?; 7119 8201 let codec = tonic::codec::ProstCodec::default(); 7120 7120 - let path = 7121 7121 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundUnit"); 8202 8202 + let path = http::uri::PathAndQuery::from_static( 8203 8203 + "/rockbox.v1alpha1.SoundService/SoundUnit", 8204 8204 + ); 7122 8205 let mut req = request.into_request(); 7123 7123 - req.extensions_mut().insert(GrpcMethod::new( 7124 7124 - "rockbox.v1alpha1.SoundService", 7125 7125 - "SoundUnit", 7126 7126 - )); 8206 8206 + req.extensions_mut() 8207 8207 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundUnit")); 7127 8208 self.inner.unary(req, path, codec).await 7128 8209 } 7129 8210 pub async fn sound_val2_phys( 7130 8211 &mut self, 7131 8212 request: impl tonic::IntoRequest<super::SoundVal2PhysRequest>, 7132 7132 - ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status> 7133 7133 - { 7134 7134 - self.inner.ready().await.map_err(|e| { 7135 7135 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7136 7136 - })?; 8213 8213 + ) -> std::result::Result< 8214 8214 + tonic::Response<super::SoundVal2PhysResponse>, 8215 8215 + tonic::Status, 8216 8216 + > { 8217 8217 + self.inner 8218 8218 + .ready() 8219 8219 + .await 8220 8220 + .map_err(|e| { 8221 8221 + tonic::Status::unknown( 8222 8222 + format!("Service was not ready: {}", e.into()), 8223 8223 + ) 8224 8224 + })?; 7137 8225 let codec = tonic::codec::ProstCodec::default(); 7138 8226 let path = http::uri::PathAndQuery::from_static( 7139 8227 "/rockbox.v1alpha1.SoundService/SoundVal2Phys", 7140 8228 ); 7141 8229 let mut req = request.into_request(); 7142 7142 - req.extensions_mut().insert(GrpcMethod::new( 7143 7143 - "rockbox.v1alpha1.SoundService", 7144 7144 - "SoundVal2Phys", 7145 7145 - )); 8230 8230 + req.extensions_mut() 8231 8231 + .insert( 8232 8232 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundVal2Phys"), 8233 8233 + ); 7146 8234 self.inner.unary(req, path, codec).await 7147 8235 } 7148 8236 pub async fn get_pitch( 7149 8237 &mut self, 7150 8238 request: impl tonic::IntoRequest<super::GetPitchRequest>, 7151 7151 - ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status> { 7152 7152 - self.inner.ready().await.map_err(|e| { 7153 7153 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7154 7154 - })?; 8239 8239 + ) -> std::result::Result< 8240 8240 + tonic::Response<super::GetPitchResponse>, 8241 8241 + tonic::Status, 8242 8242 + > { 8243 8243 + self.inner 8244 8244 + .ready() 8245 8245 + .await 8246 8246 + .map_err(|e| { 8247 8247 + tonic::Status::unknown( 8248 8248 + format!("Service was not ready: {}", e.into()), 8249 8249 + ) 8250 8250 + })?; 7155 8251 let codec = tonic::codec::ProstCodec::default(); 7156 7156 - let path = 7157 7157 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/GetPitch"); 8252 8252 + let path = http::uri::PathAndQuery::from_static( 8253 8253 + "/rockbox.v1alpha1.SoundService/GetPitch", 8254 8254 + ); 7158 8255 let mut req = request.into_request(); 7159 8256 req.extensions_mut() 7160 8257 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "GetPitch")); ··· 7163 8260 pub async fn set_pitch( 7164 8261 &mut self, 7165 8262 request: impl tonic::IntoRequest<super::SetPitchRequest>, 7166 7166 - ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status> { 7167 7167 - self.inner.ready().await.map_err(|e| { 7168 7168 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7169 7169 - })?; 8263 8263 + ) -> std::result::Result< 8264 8264 + tonic::Response<super::SetPitchResponse>, 8265 8265 + tonic::Status, 8266 8266 + > { 8267 8267 + self.inner 8268 8268 + .ready() 8269 8269 + .await 8270 8270 + .map_err(|e| { 8271 8271 + tonic::Status::unknown( 8272 8272 + format!("Service was not ready: {}", e.into()), 8273 8273 + ) 8274 8274 + })?; 7170 8275 let codec = tonic::codec::ProstCodec::default(); 7171 7171 - let path = 7172 7172 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SetPitch"); 8276 8276 + let path = http::uri::PathAndQuery::from_static( 8277 8277 + "/rockbox.v1alpha1.SoundService/SetPitch", 8278 8278 + ); 7173 8279 let mut req = request.into_request(); 7174 8280 req.extensions_mut() 7175 8281 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SetPitch")); ··· 7178 8284 pub async fn beep_play( 7179 8285 &mut self, 7180 8286 request: impl tonic::IntoRequest<super::BeepPlayRequest>, 7181 7181 - ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status> { 7182 7182 - self.inner.ready().await.map_err(|e| { 7183 7183 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7184 7184 - })?; 8287 8287 + ) -> std::result::Result< 8288 8288 + tonic::Response<super::BeepPlayResponse>, 8289 8289 + tonic::Status, 8290 8290 + > { 8291 8291 + self.inner 8292 8292 + .ready() 8293 8293 + .await 8294 8294 + .map_err(|e| { 8295 8295 + tonic::Status::unknown( 8296 8296 + format!("Service was not ready: {}", e.into()), 8297 8297 + ) 8298 8298 + })?; 7185 8299 let codec = tonic::codec::ProstCodec::default(); 7186 7186 - let path = 7187 7187 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/BeepPlay"); 8300 8300 + let path = http::uri::PathAndQuery::from_static( 8301 8301 + "/rockbox.v1alpha1.SoundService/BeepPlay", 8302 8302 + ); 7188 8303 let mut req = request.into_request(); 7189 8304 req.extensions_mut() 7190 8305 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "BeepPlay")); ··· 7193 8308 pub async fn pcmbuf_fade( 7194 8309 &mut self, 7195 8310 request: impl tonic::IntoRequest<super::PcmbufFadeRequest>, 7196 7196 - ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status> 7197 7197 - { 7198 7198 - self.inner.ready().await.map_err(|e| { 7199 7199 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7200 7200 - })?; 8311 8311 + ) -> std::result::Result< 8312 8312 + tonic::Response<super::PcmbufFadeResponse>, 8313 8313 + tonic::Status, 8314 8314 + > { 8315 8315 + self.inner 8316 8316 + .ready() 8317 8317 + .await 8318 8318 + .map_err(|e| { 8319 8319 + tonic::Status::unknown( 8320 8320 + format!("Service was not ready: {}", e.into()), 8321 8321 + ) 8322 8322 + })?; 7201 8323 let codec = tonic::codec::ProstCodec::default(); 7202 7202 - let path = 7203 7203 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/PcmbufFade"); 8324 8324 + let path = http::uri::PathAndQuery::from_static( 8325 8325 + "/rockbox.v1alpha1.SoundService/PcmbufFade", 8326 8326 + ); 7204 8327 let mut req = request.into_request(); 7205 7205 - req.extensions_mut().insert(GrpcMethod::new( 7206 7206 - "rockbox.v1alpha1.SoundService", 7207 7207 - "PcmbufFade", 7208 7208 - )); 8328 8328 + req.extensions_mut() 8329 8329 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "PcmbufFade")); 7209 8330 self.inner.unary(req, path, codec).await 7210 8331 } 7211 8332 pub async fn pcmbuf_set_low_latency( 7212 8333 &mut self, 7213 8334 request: impl tonic::IntoRequest<super::PcmbufSetLowLatencyRequest>, 7214 7214 - ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status> 7215 7215 - { 7216 7216 - self.inner.ready().await.map_err(|e| { 7217 7217 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7218 7218 - })?; 8335 8335 + ) -> std::result::Result< 8336 8336 + tonic::Response<super::PcmbufSetLowLatencyResponse>, 8337 8337 + tonic::Status, 8338 8338 + > { 8339 8339 + self.inner 8340 8340 + .ready() 8341 8341 + .await 8342 8342 + .map_err(|e| { 8343 8343 + tonic::Status::unknown( 8344 8344 + format!("Service was not ready: {}", e.into()), 8345 8345 + ) 8346 8346 + })?; 7219 8347 let codec = tonic::codec::ProstCodec::default(); 7220 8348 let path = http::uri::PathAndQuery::from_static( 7221 8349 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency", 7222 8350 ); 7223 8351 let mut req = request.into_request(); 7224 7224 - req.extensions_mut().insert(GrpcMethod::new( 7225 7225 - "rockbox.v1alpha1.SoundService", 7226 7226 - "PcmbufSetLowLatency", 7227 7227 - )); 8352 8352 + req.extensions_mut() 8353 8353 + .insert( 8354 8354 + GrpcMethod::new( 8355 8355 + "rockbox.v1alpha1.SoundService", 8356 8356 + "PcmbufSetLowLatency", 8357 8357 + ), 8358 8358 + ); 7228 8359 self.inner.unary(req, path, codec).await 7229 8360 } 7230 8361 pub async fn system_sound_play( 7231 8362 &mut self, 7232 8363 request: impl tonic::IntoRequest<super::SystemSoundPlayRequest>, 7233 7233 - ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status> 7234 7234 - { 7235 7235 - self.inner.ready().await.map_err(|e| { 7236 7236 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7237 7237 - })?; 8364 8364 + ) -> std::result::Result< 8365 8365 + tonic::Response<super::SystemSoundPlayResponse>, 8366 8366 + tonic::Status, 8367 8367 + > { 8368 8368 + self.inner 8369 8369 + .ready() 8370 8370 + .await 8371 8371 + .map_err(|e| { 8372 8372 + tonic::Status::unknown( 8373 8373 + format!("Service was not ready: {}", e.into()), 8374 8374 + ) 8375 8375 + })?; 7238 8376 let codec = tonic::codec::ProstCodec::default(); 7239 8377 let path = http::uri::PathAndQuery::from_static( 7240 8378 "/rockbox.v1alpha1.SoundService/SystemSoundPlay", 7241 8379 ); 7242 8380 let mut req = request.into_request(); 7243 7243 - req.extensions_mut().insert(GrpcMethod::new( 7244 7244 - "rockbox.v1alpha1.SoundService", 7245 7245 - "SystemSoundPlay", 7246 7246 - )); 8381 8381 + req.extensions_mut() 8382 8382 + .insert( 8383 8383 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SystemSoundPlay"), 8384 8384 + ); 7247 8385 self.inner.unary(req, path, codec).await 7248 8386 } 7249 8387 pub async fn keyclick_click( 7250 8388 &mut self, 7251 8389 request: impl tonic::IntoRequest<super::KeyclickClickRequest>, 7252 7252 - ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status> 7253 7253 - { 7254 7254 - self.inner.ready().await.map_err(|e| { 7255 7255 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7256 7256 - })?; 8390 8390 + ) -> std::result::Result< 8391 8391 + tonic::Response<super::KeyclickClickResponse>, 8392 8392 + tonic::Status, 8393 8393 + > { 8394 8394 + self.inner 8395 8395 + .ready() 8396 8396 + .await 8397 8397 + .map_err(|e| { 8398 8398 + tonic::Status::unknown( 8399 8399 + format!("Service was not ready: {}", e.into()), 8400 8400 + ) 8401 8401 + })?; 7257 8402 let codec = tonic::codec::ProstCodec::default(); 7258 8403 let path = http::uri::PathAndQuery::from_static( 7259 8404 "/rockbox.v1alpha1.SoundService/KeyclickClick", 7260 8405 ); 7261 8406 let mut req = request.into_request(); 7262 7262 - req.extensions_mut().insert(GrpcMethod::new( 7263 7263 - "rockbox.v1alpha1.SoundService", 7264 7264 - "KeyclickClick", 7265 7265 - )); 8407 8407 + req.extensions_mut() 8408 8408 + .insert( 8409 8409 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "KeyclickClick"), 8410 8410 + ); 7266 8411 self.inner.unary(req, path, codec).await 7267 8412 } 7268 8413 } ··· 7274 8419 dead_code, 7275 8420 missing_docs, 7276 8421 clippy::wildcard_imports, 7277 7277 - clippy::let_unit_value 8422 8422 + clippy::let_unit_value, 7278 8423 )] 7279 8424 use tonic::codegen::*; 7280 8425 /// Generated trait containing gRPC methods that should be implemented for use with SoundServiceServer. ··· 7283 8428 async fn adjust_volume( 7284 8429 &self, 7285 8430 request: tonic::Request<super::AdjustVolumeRequest>, 7286 7286 - ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status>; 8431 8431 + ) -> std::result::Result< 8432 8432 + tonic::Response<super::AdjustVolumeResponse>, 8433 8433 + tonic::Status, 8434 8434 + >; 7287 8435 async fn sound_set( 7288 8436 &self, 7289 8437 request: tonic::Request<super::SoundSetRequest>, 7290 7290 - ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status>; 8438 8438 + ) -> std::result::Result< 8439 8439 + tonic::Response<super::SoundSetResponse>, 8440 8440 + tonic::Status, 8441 8441 + >; 7291 8442 async fn sound_current( 7292 8443 &self, 7293 8444 request: tonic::Request<super::SoundCurrentRequest>, 7294 7294 - ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status>; 8445 8445 + ) -> std::result::Result< 8446 8446 + tonic::Response<super::SoundCurrentResponse>, 8447 8447 + tonic::Status, 8448 8448 + >; 7295 8449 async fn sound_default( 7296 8450 &self, 7297 8451 request: tonic::Request<super::SoundDefaultRequest>, 7298 7298 - ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status>; 8452 8452 + ) -> std::result::Result< 8453 8453 + tonic::Response<super::SoundDefaultResponse>, 8454 8454 + tonic::Status, 8455 8455 + >; 7299 8456 async fn sound_min( 7300 8457 &self, 7301 8458 request: tonic::Request<super::SoundMinRequest>, 7302 7302 - ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status>; 8459 8459 + ) -> std::result::Result< 8460 8460 + tonic::Response<super::SoundMinResponse>, 8461 8461 + tonic::Status, 8462 8462 + >; 7303 8463 async fn sound_max( 7304 8464 &self, 7305 8465 request: tonic::Request<super::SoundMaxRequest>, 7306 7306 - ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status>; 8466 8466 + ) -> std::result::Result< 8467 8467 + tonic::Response<super::SoundMaxResponse>, 8468 8468 + tonic::Status, 8469 8469 + >; 7307 8470 async fn sound_unit( 7308 8471 &self, 7309 8472 request: tonic::Request<super::SoundUnitRequest>, 7310 7310 - ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status>; 8473 8473 + ) -> std::result::Result< 8474 8474 + tonic::Response<super::SoundUnitResponse>, 8475 8475 + tonic::Status, 8476 8476 + >; 7311 8477 async fn sound_val2_phys( 7312 8478 &self, 7313 8479 request: tonic::Request<super::SoundVal2PhysRequest>, 7314 7314 - ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status>; 8480 8480 + ) -> std::result::Result< 8481 8481 + tonic::Response<super::SoundVal2PhysResponse>, 8482 8482 + tonic::Status, 8483 8483 + >; 7315 8484 async fn get_pitch( 7316 8485 &self, 7317 8486 request: tonic::Request<super::GetPitchRequest>, 7318 7318 - ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status>; 8487 8487 + ) -> std::result::Result< 8488 8488 + tonic::Response<super::GetPitchResponse>, 8489 8489 + tonic::Status, 8490 8490 + >; 7319 8491 async fn set_pitch( 7320 8492 &self, 7321 8493 request: tonic::Request<super::SetPitchRequest>, 7322 7322 - ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status>; 8494 8494 + ) -> std::result::Result< 8495 8495 + tonic::Response<super::SetPitchResponse>, 8496 8496 + tonic::Status, 8497 8497 + >; 7323 8498 async fn beep_play( 7324 8499 &self, 7325 8500 request: tonic::Request<super::BeepPlayRequest>, 7326 7326 - ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status>; 8501 8501 + ) -> std::result::Result< 8502 8502 + tonic::Response<super::BeepPlayResponse>, 8503 8503 + tonic::Status, 8504 8504 + >; 7327 8505 async fn pcmbuf_fade( 7328 8506 &self, 7329 8507 request: tonic::Request<super::PcmbufFadeRequest>, 7330 7330 - ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status>; 8508 8508 + ) -> std::result::Result< 8509 8509 + tonic::Response<super::PcmbufFadeResponse>, 8510 8510 + tonic::Status, 8511 8511 + >; 7331 8512 async fn pcmbuf_set_low_latency( 7332 8513 &self, 7333 8514 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 7334 7334 - ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status>; 8515 8515 + ) -> std::result::Result< 8516 8516 + tonic::Response<super::PcmbufSetLowLatencyResponse>, 8517 8517 + tonic::Status, 8518 8518 + >; 7335 8519 async fn system_sound_play( 7336 8520 &self, 7337 8521 request: tonic::Request<super::SystemSoundPlayRequest>, 7338 7338 - ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status>; 8522 8522 + ) -> std::result::Result< 8523 8523 + tonic::Response<super::SystemSoundPlayResponse>, 8524 8524 + tonic::Status, 8525 8525 + >; 7339 8526 async fn keyclick_click( 7340 8527 &self, 7341 8528 request: tonic::Request<super::KeyclickClickRequest>, 7342 7342 - ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>; 8529 8529 + ) -> std::result::Result< 8530 8530 + tonic::Response<super::KeyclickClickResponse>, 8531 8531 + tonic::Status, 8532 8532 + >; 7343 8533 } 7344 8534 #[derive(Debug)] 7345 8535 pub struct SoundServiceServer<T> { ··· 7362 8552 max_encoding_message_size: None, 7363 8553 } 7364 8554 } 7365 7365 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 8555 8555 + pub fn with_interceptor<F>( 8556 8556 + inner: T, 8557 8557 + interceptor: F, 8558 8558 + ) -> InterceptedService<Self, F> 7366 8559 where 7367 8560 F: tonic::service::Interceptor, 7368 8561 { ··· 7417 8610 "/rockbox.v1alpha1.SoundService/AdjustVolume" => { 7418 8611 #[allow(non_camel_case_types)] 7419 8612 struct AdjustVolumeSvc<T: SoundService>(pub Arc<T>); 7420 7420 - impl<T: SoundService> tonic::server::UnaryService<super::AdjustVolumeRequest> 7421 7421 - for AdjustVolumeSvc<T> 7422 7422 - { 8613 8613 + impl< 8614 8614 + T: SoundService, 8615 8615 + > tonic::server::UnaryService<super::AdjustVolumeRequest> 8616 8616 + for AdjustVolumeSvc<T> { 7423 8617 type Response = super::AdjustVolumeResponse; 7424 7424 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8618 8618 + type Future = BoxFuture< 8619 8619 + tonic::Response<Self::Response>, 8620 8620 + tonic::Status, 8621 8621 + >; 7425 8622 fn call( 7426 8623 &mut self, 7427 8624 request: tonic::Request<super::AdjustVolumeRequest>, ··· 7458 8655 "/rockbox.v1alpha1.SoundService/SoundSet" => { 7459 8656 #[allow(non_camel_case_types)] 7460 8657 struct SoundSetSvc<T: SoundService>(pub Arc<T>); 7461 7461 - impl<T: SoundService> tonic::server::UnaryService<super::SoundSetRequest> for SoundSetSvc<T> { 8658 8658 + impl< 8659 8659 + T: SoundService, 8660 8660 + > tonic::server::UnaryService<super::SoundSetRequest> 8661 8661 + for SoundSetSvc<T> { 7462 8662 type Response = super::SoundSetResponse; 7463 7463 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8663 8663 + type Future = BoxFuture< 8664 8664 + tonic::Response<Self::Response>, 8665 8665 + tonic::Status, 8666 8666 + >; 7464 8667 fn call( 7465 8668 &mut self, 7466 8669 request: tonic::Request<super::SoundSetRequest>, ··· 7497 8700 "/rockbox.v1alpha1.SoundService/SoundCurrent" => { 7498 8701 #[allow(non_camel_case_types)] 7499 8702 struct SoundCurrentSvc<T: SoundService>(pub Arc<T>); 7500 7500 - impl<T: SoundService> tonic::server::UnaryService<super::SoundCurrentRequest> 7501 7501 - for SoundCurrentSvc<T> 7502 7502 - { 8703 8703 + impl< 8704 8704 + T: SoundService, 8705 8705 + > tonic::server::UnaryService<super::SoundCurrentRequest> 8706 8706 + for SoundCurrentSvc<T> { 7503 8707 type Response = super::SoundCurrentResponse; 7504 7504 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8708 8708 + type Future = BoxFuture< 8709 8709 + tonic::Response<Self::Response>, 8710 8710 + tonic::Status, 8711 8711 + >; 7505 8712 fn call( 7506 8713 &mut self, 7507 8714 request: tonic::Request<super::SoundCurrentRequest>, ··· 7538 8745 "/rockbox.v1alpha1.SoundService/SoundDefault" => { 7539 8746 #[allow(non_camel_case_types)] 7540 8747 struct SoundDefaultSvc<T: SoundService>(pub Arc<T>); 7541 7541 - impl<T: SoundService> tonic::server::UnaryService<super::SoundDefaultRequest> 7542 7542 - for SoundDefaultSvc<T> 7543 7543 - { 8748 8748 + impl< 8749 8749 + T: SoundService, 8750 8750 + > tonic::server::UnaryService<super::SoundDefaultRequest> 8751 8751 + for SoundDefaultSvc<T> { 7544 8752 type Response = super::SoundDefaultResponse; 7545 7545 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8753 8753 + type Future = BoxFuture< 8754 8754 + tonic::Response<Self::Response>, 8755 8755 + tonic::Status, 8756 8756 + >; 7546 8757 fn call( 7547 8758 &mut self, 7548 8759 request: tonic::Request<super::SoundDefaultRequest>, ··· 7579 8790 "/rockbox.v1alpha1.SoundService/SoundMin" => { 7580 8791 #[allow(non_camel_case_types)] 7581 8792 struct SoundMinSvc<T: SoundService>(pub Arc<T>); 7582 7582 - impl<T: SoundService> tonic::server::UnaryService<super::SoundMinRequest> for SoundMinSvc<T> { 8793 8793 + impl< 8794 8794 + T: SoundService, 8795 8795 + > tonic::server::UnaryService<super::SoundMinRequest> 8796 8796 + for SoundMinSvc<T> { 7583 8797 type Response = super::SoundMinResponse; 7584 7584 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8798 8798 + type Future = BoxFuture< 8799 8799 + tonic::Response<Self::Response>, 8800 8800 + tonic::Status, 8801 8801 + >; 7585 8802 fn call( 7586 8803 &mut self, 7587 8804 request: tonic::Request<super::SoundMinRequest>, ··· 7618 8835 "/rockbox.v1alpha1.SoundService/SoundMax" => { 7619 8836 #[allow(non_camel_case_types)] 7620 8837 struct SoundMaxSvc<T: SoundService>(pub Arc<T>); 7621 7621 - impl<T: SoundService> tonic::server::UnaryService<super::SoundMaxRequest> for SoundMaxSvc<T> { 8838 8838 + impl< 8839 8839 + T: SoundService, 8840 8840 + > tonic::server::UnaryService<super::SoundMaxRequest> 8841 8841 + for SoundMaxSvc<T> { 7622 8842 type Response = super::SoundMaxResponse; 7623 7623 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8843 8843 + type Future = BoxFuture< 8844 8844 + tonic::Response<Self::Response>, 8845 8845 + tonic::Status, 8846 8846 + >; 7624 8847 fn call( 7625 8848 &mut self, 7626 8849 request: tonic::Request<super::SoundMaxRequest>, ··· 7657 8880 "/rockbox.v1alpha1.SoundService/SoundUnit" => { 7658 8881 #[allow(non_camel_case_types)] 7659 8882 struct SoundUnitSvc<T: SoundService>(pub Arc<T>); 7660 7660 - impl<T: SoundService> tonic::server::UnaryService<super::SoundUnitRequest> for SoundUnitSvc<T> { 8883 8883 + impl< 8884 8884 + T: SoundService, 8885 8885 + > tonic::server::UnaryService<super::SoundUnitRequest> 8886 8886 + for SoundUnitSvc<T> { 7661 8887 type Response = super::SoundUnitResponse; 7662 7662 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8888 8888 + type Future = BoxFuture< 8889 8889 + tonic::Response<Self::Response>, 8890 8890 + tonic::Status, 8891 8891 + >; 7663 8892 fn call( 7664 8893 &mut self, 7665 8894 request: tonic::Request<super::SoundUnitRequest>, ··· 7696 8925 "/rockbox.v1alpha1.SoundService/SoundVal2Phys" => { 7697 8926 #[allow(non_camel_case_types)] 7698 8927 struct SoundVal2PhysSvc<T: SoundService>(pub Arc<T>); 7699 7699 - impl<T: SoundService> tonic::server::UnaryService<super::SoundVal2PhysRequest> 7700 7700 - for SoundVal2PhysSvc<T> 7701 7701 - { 8928 8928 + impl< 8929 8929 + T: SoundService, 8930 8930 + > tonic::server::UnaryService<super::SoundVal2PhysRequest> 8931 8931 + for SoundVal2PhysSvc<T> { 7702 8932 type Response = super::SoundVal2PhysResponse; 7703 7703 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8933 8933 + type Future = BoxFuture< 8934 8934 + tonic::Response<Self::Response>, 8935 8935 + tonic::Status, 8936 8936 + >; 7704 8937 fn call( 7705 8938 &mut self, 7706 8939 request: tonic::Request<super::SoundVal2PhysRequest>, ··· 7737 8970 "/rockbox.v1alpha1.SoundService/GetPitch" => { 7738 8971 #[allow(non_camel_case_types)] 7739 8972 struct GetPitchSvc<T: SoundService>(pub Arc<T>); 7740 7740 - impl<T: SoundService> tonic::server::UnaryService<super::GetPitchRequest> for GetPitchSvc<T> { 8973 8973 + impl< 8974 8974 + T: SoundService, 8975 8975 + > tonic::server::UnaryService<super::GetPitchRequest> 8976 8976 + for GetPitchSvc<T> { 7741 8977 type Response = super::GetPitchResponse; 7742 7742 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8978 8978 + type Future = BoxFuture< 8979 8979 + tonic::Response<Self::Response>, 8980 8980 + tonic::Status, 8981 8981 + >; 7743 8982 fn call( 7744 8983 &mut self, 7745 8984 request: tonic::Request<super::GetPitchRequest>, ··· 7776 9015 "/rockbox.v1alpha1.SoundService/SetPitch" => { 7777 9016 #[allow(non_camel_case_types)] 7778 9017 struct SetPitchSvc<T: SoundService>(pub Arc<T>); 7779 7779 - impl<T: SoundService> tonic::server::UnaryService<super::SetPitchRequest> for SetPitchSvc<T> { 9018 9018 + impl< 9019 9019 + T: SoundService, 9020 9020 + > tonic::server::UnaryService<super::SetPitchRequest> 9021 9021 + for SetPitchSvc<T> { 7780 9022 type Response = super::SetPitchResponse; 7781 7781 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9023 9023 + type Future = BoxFuture< 9024 9024 + tonic::Response<Self::Response>, 9025 9025 + tonic::Status, 9026 9026 + >; 7782 9027 fn call( 7783 9028 &mut self, 7784 9029 request: tonic::Request<super::SetPitchRequest>, ··· 7815 9060 "/rockbox.v1alpha1.SoundService/BeepPlay" => { 7816 9061 #[allow(non_camel_case_types)] 7817 9062 struct BeepPlaySvc<T: SoundService>(pub Arc<T>); 7818 7818 - impl<T: SoundService> tonic::server::UnaryService<super::BeepPlayRequest> for BeepPlaySvc<T> { 9063 9063 + impl< 9064 9064 + T: SoundService, 9065 9065 + > tonic::server::UnaryService<super::BeepPlayRequest> 9066 9066 + for BeepPlaySvc<T> { 7819 9067 type Response = super::BeepPlayResponse; 7820 7820 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9068 9068 + type Future = BoxFuture< 9069 9069 + tonic::Response<Self::Response>, 9070 9070 + tonic::Status, 9071 9071 + >; 7821 9072 fn call( 7822 9073 &mut self, 7823 9074 request: tonic::Request<super::BeepPlayRequest>, ··· 7854 9105 "/rockbox.v1alpha1.SoundService/PcmbufFade" => { 7855 9106 #[allow(non_camel_case_types)] 7856 9107 struct PcmbufFadeSvc<T: SoundService>(pub Arc<T>); 7857 7857 - impl<T: SoundService> tonic::server::UnaryService<super::PcmbufFadeRequest> for PcmbufFadeSvc<T> { 9108 9108 + impl< 9109 9109 + T: SoundService, 9110 9110 + > tonic::server::UnaryService<super::PcmbufFadeRequest> 9111 9111 + for PcmbufFadeSvc<T> { 7858 9112 type Response = super::PcmbufFadeResponse; 7859 7859 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9113 9113 + type Future = BoxFuture< 9114 9114 + tonic::Response<Self::Response>, 9115 9115 + tonic::Status, 9116 9116 + >; 7860 9117 fn call( 7861 9118 &mut self, 7862 9119 request: tonic::Request<super::PcmbufFadeRequest>, ··· 7893 9150 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency" => { 7894 9151 #[allow(non_camel_case_types)] 7895 9152 struct PcmbufSetLowLatencySvc<T: SoundService>(pub Arc<T>); 7896 7896 - impl<T: SoundService> 7897 7897 - tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 7898 7898 - for PcmbufSetLowLatencySvc<T> 7899 7899 - { 9153 9153 + impl< 9154 9154 + T: SoundService, 9155 9155 + > tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 9156 9156 + for PcmbufSetLowLatencySvc<T> { 7900 9157 type Response = super::PcmbufSetLowLatencyResponse; 7901 7901 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9158 9158 + type Future = BoxFuture< 9159 9159 + tonic::Response<Self::Response>, 9160 9160 + tonic::Status, 9161 9161 + >; 7902 9162 fn call( 7903 9163 &mut self, 7904 9164 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 7905 9165 ) -> Self::Future { 7906 9166 let inner = Arc::clone(&self.0); 7907 9167 let fut = async move { 7908 7908 - <T as SoundService>::pcmbuf_set_low_latency(&inner, request).await 9168 9168 + <T as SoundService>::pcmbuf_set_low_latency(&inner, request) 9169 9169 + .await 7909 9170 }; 7910 9171 Box::pin(fut) 7911 9172 } ··· 7935 9196 "/rockbox.v1alpha1.SoundService/SystemSoundPlay" => { 7936 9197 #[allow(non_camel_case_types)] 7937 9198 struct SystemSoundPlaySvc<T: SoundService>(pub Arc<T>); 7938 7938 - impl<T: SoundService> tonic::server::UnaryService<super::SystemSoundPlayRequest> 7939 7939 - for SystemSoundPlaySvc<T> 7940 7940 - { 9199 9199 + impl< 9200 9200 + T: SoundService, 9201 9201 + > tonic::server::UnaryService<super::SystemSoundPlayRequest> 9202 9202 + for SystemSoundPlaySvc<T> { 7941 9203 type Response = super::SystemSoundPlayResponse; 7942 7942 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9204 9204 + type Future = BoxFuture< 9205 9205 + tonic::Response<Self::Response>, 9206 9206 + tonic::Status, 9207 9207 + >; 7943 9208 fn call( 7944 9209 &mut self, 7945 9210 request: tonic::Request<super::SystemSoundPlayRequest>, 7946 9211 ) -> Self::Future { 7947 9212 let inner = Arc::clone(&self.0); 7948 9213 let fut = async move { 7949 7949 - <T as SoundService>::system_sound_play(&inner, request).await 9214 9214 + <T as SoundService>::system_sound_play(&inner, request) 9215 9215 + .await 7950 9216 }; 7951 9217 Box::pin(fut) 7952 9218 } ··· 7976 9242 "/rockbox.v1alpha1.SoundService/KeyclickClick" => { 7977 9243 #[allow(non_camel_case_types)] 7978 9244 struct KeyclickClickSvc<T: SoundService>(pub Arc<T>); 7979 7979 - impl<T: SoundService> tonic::server::UnaryService<super::KeyclickClickRequest> 7980 7980 - for KeyclickClickSvc<T> 7981 7981 - { 9245 9245 + impl< 9246 9246 + T: SoundService, 9247 9247 + > tonic::server::UnaryService<super::KeyclickClickRequest> 9248 9248 + for KeyclickClickSvc<T> { 7982 9249 type Response = super::KeyclickClickResponse; 7983 7983 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9250 9250 + type Future = BoxFuture< 9251 9251 + tonic::Response<Self::Response>, 9252 9252 + tonic::Status, 9253 9253 + >; 7984 9254 fn call( 7985 9255 &mut self, 7986 9256 request: tonic::Request<super::KeyclickClickRequest>, ··· 8014 9284 }; 8015 9285 Box::pin(fut) 8016 9286 } 8017 8017 - _ => Box::pin(async move { 8018 8018 - let mut response = http::Response::new(empty_body()); 8019 8019 - let headers = response.headers_mut(); 8020 8020 - headers.insert( 8021 8021 - tonic::Status::GRPC_STATUS, 8022 8022 - (tonic::Code::Unimplemented as i32).into(), 8023 8023 - ); 8024 8024 - headers.insert( 8025 8025 - http::header::CONTENT_TYPE, 8026 8026 - tonic::metadata::GRPC_CONTENT_TYPE, 8027 8027 - ); 8028 8028 - Ok(response) 8029 8029 - }), 9287 9287 + _ => { 9288 9288 + Box::pin(async move { 9289 9289 + let mut response = http::Response::new(empty_body()); 9290 9290 + let headers = response.headers_mut(); 9291 9291 + headers 9292 9292 + .insert( 9293 9293 + tonic::Status::GRPC_STATUS, 9294 9294 + (tonic::Code::Unimplemented as i32).into(), 9295 9295 + ); 9296 9296 + headers 9297 9297 + .insert( 9298 9298 + http::header::CONTENT_TYPE, 9299 9299 + tonic::metadata::GRPC_CONTENT_TYPE, 9300 9300 + ); 9301 9301 + Ok(response) 9302 9302 + }) 9303 9303 + } 8030 9304 } 8031 9305 } 8032 9306 } ··· 8087 9361 dead_code, 8088 9362 missing_docs, 8089 9363 clippy::wildcard_imports, 8090 8090 - clippy::let_unit_value 9364 9364 + clippy::let_unit_value, 8091 9365 )] 8092 8092 - use tonic::codegen::http::Uri; 8093 9366 use tonic::codegen::*; 9367 9367 + use tonic::codegen::http::Uri; 8094 9368 #[derive(Debug, Clone)] 8095 9369 pub struct SystemServiceClient<T> { 8096 9370 inner: tonic::client::Grpc<T>, ··· 8134 9408 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 8135 9409 >, 8136 9410 >, 8137 8137 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 8138 8138 - Into<StdError> + std::marker::Send + std::marker::Sync, 9411 9411 + <T as tonic::codegen::Service< 9412 9412 + http::Request<tonic::body::BoxBody>, 9413 9413 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 8139 9414 { 8140 9415 SystemServiceClient::new(InterceptedService::new(inner, interceptor)) 8141 9416 } ··· 8173 9448 pub async fn get_rockbox_version( 8174 9449 &mut self, 8175 9450 request: impl tonic::IntoRequest<super::GetRockboxVersionRequest>, 8176 8176 - ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status> 8177 8177 - { 8178 8178 - self.inner.ready().await.map_err(|e| { 8179 8179 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 8180 8180 - })?; 9451 9451 + ) -> std::result::Result< 9452 9452 + tonic::Response<super::GetRockboxVersionResponse>, 9453 9453 + tonic::Status, 9454 9454 + > { 9455 9455 + self.inner 9456 9456 + .ready() 9457 9457 + .await 9458 9458 + .map_err(|e| { 9459 9459 + tonic::Status::unknown( 9460 9460 + format!("Service was not ready: {}", e.into()), 9461 9461 + ) 9462 9462 + })?; 8181 9463 let codec = tonic::codec::ProstCodec::default(); 8182 9464 let path = http::uri::PathAndQuery::from_static( 8183 9465 "/rockbox.v1alpha1.SystemService/GetRockboxVersion", 8184 9466 ); 8185 9467 let mut req = request.into_request(); 8186 8186 - req.extensions_mut().insert(GrpcMethod::new( 8187 8187 - "rockbox.v1alpha1.SystemService", 8188 8188 - "GetRockboxVersion", 8189 8189 - )); 9468 9468 + req.extensions_mut() 9469 9469 + .insert( 9470 9470 + GrpcMethod::new( 9471 9471 + "rockbox.v1alpha1.SystemService", 9472 9472 + "GetRockboxVersion", 9473 9473 + ), 9474 9474 + ); 8190 9475 self.inner.unary(req, path, codec).await 8191 9476 } 8192 9477 pub async fn get_global_status( 8193 9478 &mut self, 8194 9479 request: impl tonic::IntoRequest<super::GetGlobalStatusRequest>, 8195 8195 - ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status> 8196 8196 - { 8197 8197 - self.inner.ready().await.map_err(|e| { 8198 8198 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 8199 8199 - })?; 9480 9480 + ) -> std::result::Result< 9481 9481 + tonic::Response<super::GetGlobalStatusResponse>, 9482 9482 + tonic::Status, 9483 9483 + > { 9484 9484 + self.inner 9485 9485 + .ready() 9486 9486 + .await 9487 9487 + .map_err(|e| { 9488 9488 + tonic::Status::unknown( 9489 9489 + format!("Service was not ready: {}", e.into()), 9490 9490 + ) 9491 9491 + })?; 8200 9492 let codec = tonic::codec::ProstCodec::default(); 8201 9493 let path = http::uri::PathAndQuery::from_static( 8202 9494 "/rockbox.v1alpha1.SystemService/GetGlobalStatus", 8203 9495 ); 8204 9496 let mut req = request.into_request(); 8205 8205 - req.extensions_mut().insert(GrpcMethod::new( 8206 8206 - "rockbox.v1alpha1.SystemService", 8207 8207 - "GetGlobalStatus", 8208 8208 - )); 9497 9497 + req.extensions_mut() 9498 9498 + .insert( 9499 9499 + GrpcMethod::new("rockbox.v1alpha1.SystemService", "GetGlobalStatus"), 9500 9500 + ); 8209 9501 self.inner.unary(req, path, codec).await 8210 9502 } 8211 9503 } ··· 8217 9509 dead_code, 8218 9510 missing_docs, 8219 9511 clippy::wildcard_imports, 8220 8220 - clippy::let_unit_value 9512 9512 + clippy::let_unit_value, 8221 9513 )] 8222 9514 use tonic::codegen::*; 8223 9515 /// Generated trait containing gRPC methods that should be implemented for use with SystemServiceServer. ··· 8226 9518 async fn get_rockbox_version( 8227 9519 &self, 8228 9520 request: tonic::Request<super::GetRockboxVersionRequest>, 8229 8229 - ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status>; 9521 9521 + ) -> std::result::Result< 9522 9522 + tonic::Response<super::GetRockboxVersionResponse>, 9523 9523 + tonic::Status, 9524 9524 + >; 8230 9525 async fn get_global_status( 8231 9526 &self, 8232 9527 request: tonic::Request<super::GetGlobalStatusRequest>, 8233 8233 - ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>; 9528 9528 + ) -> std::result::Result< 9529 9529 + tonic::Response<super::GetGlobalStatusResponse>, 9530 9530 + tonic::Status, 9531 9531 + >; 8234 9532 } 8235 9533 #[derive(Debug)] 8236 9534 pub struct SystemServiceServer<T> { ··· 8253 9551 max_encoding_message_size: None, 8254 9552 } 8255 9553 } 8256 8256 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 9554 9554 + pub fn with_interceptor<F>( 9555 9555 + inner: T, 9556 9556 + interceptor: F, 9557 9557 + ) -> InterceptedService<Self, F> 8257 9558 where 8258 9559 F: tonic::service::Interceptor, 8259 9560 { ··· 8308 9609 "/rockbox.v1alpha1.SystemService/GetRockboxVersion" => { 8309 9610 #[allow(non_camel_case_types)] 8310 9611 struct GetRockboxVersionSvc<T: SystemService>(pub Arc<T>); 8311 8311 - impl<T: SystemService> 8312 8312 - tonic::server::UnaryService<super::GetRockboxVersionRequest> 8313 8313 - for GetRockboxVersionSvc<T> 8314 8314 - { 9612 9612 + impl< 9613 9613 + T: SystemService, 9614 9614 + > tonic::server::UnaryService<super::GetRockboxVersionRequest> 9615 9615 + for GetRockboxVersionSvc<T> { 8315 9616 type Response = super::GetRockboxVersionResponse; 8316 8316 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9617 9617 + type Future = BoxFuture< 9618 9618 + tonic::Response<Self::Response>, 9619 9619 + tonic::Status, 9620 9620 + >; 8317 9621 fn call( 8318 9622 &mut self, 8319 9623 request: tonic::Request<super::GetRockboxVersionRequest>, 8320 9624 ) -> Self::Future { 8321 9625 let inner = Arc::clone(&self.0); 8322 9626 let fut = async move { 8323 8323 - <T as SystemService>::get_rockbox_version(&inner, request).await 9627 9627 + <T as SystemService>::get_rockbox_version(&inner, request) 9628 9628 + .await 8324 9629 }; 8325 9630 Box::pin(fut) 8326 9631 } ··· 8350 9655 "/rockbox.v1alpha1.SystemService/GetGlobalStatus" => { 8351 9656 #[allow(non_camel_case_types)] 8352 9657 struct GetGlobalStatusSvc<T: SystemService>(pub Arc<T>); 8353 8353 - impl<T: SystemService> 8354 8354 - tonic::server::UnaryService<super::GetGlobalStatusRequest> 8355 8355 - for GetGlobalStatusSvc<T> 8356 8356 - { 9658 9658 + impl< 9659 9659 + T: SystemService, 9660 9660 + > tonic::server::UnaryService<super::GetGlobalStatusRequest> 9661 9661 + for GetGlobalStatusSvc<T> { 8357 9662 type Response = super::GetGlobalStatusResponse; 8358 8358 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 9663 9663 + type Future = BoxFuture< 9664 9664 + tonic::Response<Self::Response>, 9665 9665 + tonic::Status, 9666 9666 + >; 8359 9667 fn call( 8360 9668 &mut self, 8361 9669 request: tonic::Request<super::GetGlobalStatusRequest>, 8362 9670 ) -> Self::Future { 8363 9671 let inner = Arc::clone(&self.0); 8364 9672 let fut = async move { 8365 8365 - <T as SystemService>::get_global_status(&inner, request).await 9673 9673 + <T as SystemService>::get_global_status(&inner, request) 9674 9674 + .await 8366 9675 }; 8367 9676 Box::pin(fut) 8368 9677 } ··· 8389 9698 }; 8390 9699 Box::pin(fut) 8391 9700 } 8392 8392 - _ => Box::pin(async move { 8393 8393 - let mut response = http::Response::new(empty_body()); 8394 8394 - let headers = response.headers_mut(); 8395 8395 - headers.insert( 8396 8396 - tonic::Status::GRPC_STATUS, 8397 8397 - (tonic::Code::Unimplemented as i32).into(), 8398 8398 - ); 8399 8399 - headers.insert( 8400 8400 - http::header::CONTENT_TYPE, 8401 8401 - tonic::metadata::GRPC_CONTENT_TYPE, 8402 8402 - ); 8403 8403 - Ok(response) 8404 8404 - }), 9701 9701 + _ => { 9702 9702 + Box::pin(async move { 9703 9703 + let mut response = http::Response::new(empty_body()); 9704 9704 + let headers = response.headers_mut(); 9705 9705 + headers 9706 9706 + .insert( 9707 9707 + tonic::Status::GRPC_STATUS, 9708 9708 + (tonic::Code::Unimplemented as i32).into(), 9709 9709 + ); 9710 9710 + headers 9711 9711 + .insert( 9712 9712 + http::header::CONTENT_TYPE, 9713 9713 + tonic::metadata::GRPC_CONTENT_TYPE, 9714 9714 + ); 9715 9715 + Ok(response) 9716 9716 + }) 9717 9717 + } 8405 9718 } 8406 9719 } 8407 9720 }

+2442 -1210

gtk/src/api/rockbox.v1alpha1.rs

··· 43 43 dead_code, 44 44 missing_docs, 45 45 clippy::wildcard_imports, 46 46 - clippy::let_unit_value 46 46 + clippy::let_unit_value, 47 47 )] 48 48 - use tonic::codegen::http::Uri; 49 48 use tonic::codegen::*; 49 49 + use tonic::codegen::http::Uri; 50 50 #[derive(Debug, Clone)] 51 51 pub struct BrowseServiceClient<T> { 52 52 inner: tonic::client::Grpc<T>, ··· 90 90 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 91 91 >, 92 92 >, 93 93 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 94 94 - Into<StdError> + std::marker::Send + std::marker::Sync, 93 93 + <T as tonic::codegen::Service< 94 94 + http::Request<tonic::body::BoxBody>, 95 95 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 95 96 { 96 97 BrowseServiceClient::new(InterceptedService::new(inner, interceptor)) 97 98 } ··· 129 130 pub async fn tree_get_entries( 130 131 &mut self, 131 132 request: impl tonic::IntoRequest<super::TreeGetEntriesRequest>, 132 132 - ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status> 133 133 - { 134 134 - self.inner.ready().await.map_err(|e| { 135 135 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 136 136 - })?; 133 133 + ) -> std::result::Result< 134 134 + tonic::Response<super::TreeGetEntriesResponse>, 135 135 + tonic::Status, 136 136 + > { 137 137 + self.inner 138 138 + .ready() 139 139 + .await 140 140 + .map_err(|e| { 141 141 + tonic::Status::unknown( 142 142 + format!("Service was not ready: {}", e.into()), 143 143 + ) 144 144 + })?; 137 145 let codec = tonic::codec::ProstCodec::default(); 138 146 let path = http::uri::PathAndQuery::from_static( 139 147 "/rockbox.v1alpha1.BrowseService/TreeGetEntries", 140 148 ); 141 149 let mut req = request.into_request(); 142 142 - req.extensions_mut().insert(GrpcMethod::new( 143 143 - "rockbox.v1alpha1.BrowseService", 144 144 - "TreeGetEntries", 145 145 - )); 150 150 + req.extensions_mut() 151 151 + .insert( 152 152 + GrpcMethod::new("rockbox.v1alpha1.BrowseService", "TreeGetEntries"), 153 153 + ); 146 154 self.inner.unary(req, path, codec).await 147 155 } 148 156 } ··· 154 162 dead_code, 155 163 missing_docs, 156 164 clippy::wildcard_imports, 157 157 - clippy::let_unit_value 165 165 + clippy::let_unit_value, 158 166 )] 159 167 use tonic::codegen::*; 160 168 /// Generated trait containing gRPC methods that should be implemented for use with BrowseServiceServer. ··· 163 171 async fn tree_get_entries( 164 172 &self, 165 173 request: tonic::Request<super::TreeGetEntriesRequest>, 166 166 - ) -> std::result::Result<tonic::Response<super::TreeGetEntriesResponse>, tonic::Status>; 174 174 + ) -> std::result::Result< 175 175 + tonic::Response<super::TreeGetEntriesResponse>, 176 176 + tonic::Status, 177 177 + >; 167 178 } 168 179 #[derive(Debug)] 169 180 pub struct BrowseServiceServer<T> { ··· 186 197 max_encoding_message_size: None, 187 198 } 188 199 } 189 189 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 200 200 + pub fn with_interceptor<F>( 201 201 + inner: T, 202 202 + interceptor: F, 203 203 + ) -> InterceptedService<Self, F> 190 204 where 191 205 F: tonic::service::Interceptor, 192 206 { ··· 241 255 "/rockbox.v1alpha1.BrowseService/TreeGetEntries" => { 242 256 #[allow(non_camel_case_types)] 243 257 struct TreeGetEntriesSvc<T: BrowseService>(pub Arc<T>); 244 244 - impl<T: BrowseService> tonic::server::UnaryService<super::TreeGetEntriesRequest> 245 245 - for TreeGetEntriesSvc<T> 246 246 - { 258 258 + impl< 259 259 + T: BrowseService, 260 260 + > tonic::server::UnaryService<super::TreeGetEntriesRequest> 261 261 + for TreeGetEntriesSvc<T> { 247 262 type Response = super::TreeGetEntriesResponse; 248 248 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 263 263 + type Future = BoxFuture< 264 264 + tonic::Response<Self::Response>, 265 265 + tonic::Status, 266 266 + >; 249 267 fn call( 250 268 &mut self, 251 269 request: tonic::Request<super::TreeGetEntriesRequest>, 252 270 ) -> Self::Future { 253 271 let inner = Arc::clone(&self.0); 254 272 let fut = async move { 255 255 - <T as BrowseService>::tree_get_entries(&inner, request).await 273 273 + <T as BrowseService>::tree_get_entries(&inner, request) 274 274 + .await 256 275 }; 257 276 Box::pin(fut) 258 277 } ··· 279 298 }; 280 299 Box::pin(fut) 281 300 } 282 282 - _ => Box::pin(async move { 283 283 - let mut response = http::Response::new(empty_body()); 284 284 - let headers = response.headers_mut(); 285 285 - headers.insert( 286 286 - tonic::Status::GRPC_STATUS, 287 287 - (tonic::Code::Unimplemented as i32).into(), 288 288 - ); 289 289 - headers.insert( 290 290 - http::header::CONTENT_TYPE, 291 291 - tonic::metadata::GRPC_CONTENT_TYPE, 292 292 - ); 293 293 - Ok(response) 294 294 - }), 301 301 + _ => { 302 302 + Box::pin(async move { 303 303 + let mut response = http::Response::new(empty_body()); 304 304 + let headers = response.headers_mut(); 305 305 + headers 306 306 + .insert( 307 307 + tonic::Status::GRPC_STATUS, 308 308 + (tonic::Code::Unimplemented as i32).into(), 309 309 + ); 310 310 + headers 311 311 + .insert( 312 312 + http::header::CONTENT_TYPE, 313 313 + tonic::metadata::GRPC_CONTENT_TYPE, 314 314 + ); 315 315 + Ok(response) 316 316 + }) 317 317 + } 295 318 } 296 319 } 297 320 } ··· 519 542 dead_code, 520 543 missing_docs, 521 544 clippy::wildcard_imports, 522 522 - clippy::let_unit_value 545 545 + clippy::let_unit_value, 523 546 )] 524 524 - use tonic::codegen::http::Uri; 525 547 use tonic::codegen::*; 548 548 + use tonic::codegen::http::Uri; 526 549 #[derive(Debug, Clone)] 527 550 pub struct LibraryServiceClient<T> { 528 551 inner: tonic::client::Grpc<T>, ··· 566 589 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 567 590 >, 568 591 >, 569 569 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 570 570 - Into<StdError> + std::marker::Send + std::marker::Sync, 592 592 + <T as tonic::codegen::Service< 593 593 + http::Request<tonic::body::BoxBody>, 594 594 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 571 595 { 572 596 LibraryServiceClient::new(InterceptedService::new(inner, interceptor)) 573 597 } ··· 605 629 pub async fn get_albums( 606 630 &mut self, 607 631 request: impl tonic::IntoRequest<super::GetAlbumsRequest>, 608 608 - ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status> { 609 609 - self.inner.ready().await.map_err(|e| { 610 610 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 611 611 - })?; 632 632 + ) -> std::result::Result< 633 633 + tonic::Response<super::GetAlbumsResponse>, 634 634 + tonic::Status, 635 635 + > { 636 636 + self.inner 637 637 + .ready() 638 638 + .await 639 639 + .map_err(|e| { 640 640 + tonic::Status::unknown( 641 641 + format!("Service was not ready: {}", e.into()), 642 642 + ) 643 643 + })?; 612 644 let codec = tonic::codec::ProstCodec::default(); 613 613 - let path = 614 614 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbums"); 645 645 + let path = http::uri::PathAndQuery::from_static( 646 646 + "/rockbox.v1alpha1.LibraryService/GetAlbums", 647 647 + ); 615 648 let mut req = request.into_request(); 616 616 - req.extensions_mut().insert(GrpcMethod::new( 617 617 - "rockbox.v1alpha1.LibraryService", 618 618 - "GetAlbums", 619 619 - )); 649 649 + req.extensions_mut() 650 650 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbums")); 620 651 self.inner.unary(req, path, codec).await 621 652 } 622 653 pub async fn get_artists( 623 654 &mut self, 624 655 request: impl tonic::IntoRequest<super::GetArtistsRequest>, 625 625 - ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status> 626 626 - { 627 627 - self.inner.ready().await.map_err(|e| { 628 628 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 629 629 - })?; 656 656 + ) -> std::result::Result< 657 657 + tonic::Response<super::GetArtistsResponse>, 658 658 + tonic::Status, 659 659 + > { 660 660 + self.inner 661 661 + .ready() 662 662 + .await 663 663 + .map_err(|e| { 664 664 + tonic::Status::unknown( 665 665 + format!("Service was not ready: {}", e.into()), 666 666 + ) 667 667 + })?; 630 668 let codec = tonic::codec::ProstCodec::default(); 631 631 - let path = 632 632 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtists"); 669 669 + let path = http::uri::PathAndQuery::from_static( 670 670 + "/rockbox.v1alpha1.LibraryService/GetArtists", 671 671 + ); 633 672 let mut req = request.into_request(); 634 634 - req.extensions_mut().insert(GrpcMethod::new( 635 635 - "rockbox.v1alpha1.LibraryService", 636 636 - "GetArtists", 637 637 - )); 673 673 + req.extensions_mut() 674 674 + .insert( 675 675 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtists"), 676 676 + ); 638 677 self.inner.unary(req, path, codec).await 639 678 } 640 679 pub async fn get_tracks( 641 680 &mut self, 642 681 request: impl tonic::IntoRequest<super::GetTracksRequest>, 643 643 - ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status> { 644 644 - self.inner.ready().await.map_err(|e| { 645 645 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 646 646 - })?; 682 682 + ) -> std::result::Result< 683 683 + tonic::Response<super::GetTracksResponse>, 684 684 + tonic::Status, 685 685 + > { 686 686 + self.inner 687 687 + .ready() 688 688 + .await 689 689 + .map_err(|e| { 690 690 + tonic::Status::unknown( 691 691 + format!("Service was not ready: {}", e.into()), 692 692 + ) 693 693 + })?; 647 694 let codec = tonic::codec::ProstCodec::default(); 648 648 - let path = 649 649 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTracks"); 695 695 + let path = http::uri::PathAndQuery::from_static( 696 696 + "/rockbox.v1alpha1.LibraryService/GetTracks", 697 697 + ); 650 698 let mut req = request.into_request(); 651 651 - req.extensions_mut().insert(GrpcMethod::new( 652 652 - "rockbox.v1alpha1.LibraryService", 653 653 - "GetTracks", 654 654 - )); 699 699 + req.extensions_mut() 700 700 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTracks")); 655 701 self.inner.unary(req, path, codec).await 656 702 } 657 703 pub async fn get_album( 658 704 &mut self, 659 705 request: impl tonic::IntoRequest<super::GetAlbumRequest>, 660 660 - ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status> { 661 661 - self.inner.ready().await.map_err(|e| { 662 662 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 663 663 - })?; 706 706 + ) -> std::result::Result< 707 707 + tonic::Response<super::GetAlbumResponse>, 708 708 + tonic::Status, 709 709 + > { 710 710 + self.inner 711 711 + .ready() 712 712 + .await 713 713 + .map_err(|e| { 714 714 + tonic::Status::unknown( 715 715 + format!("Service was not ready: {}", e.into()), 716 716 + ) 717 717 + })?; 664 718 let codec = tonic::codec::ProstCodec::default(); 665 665 - let path = 666 666 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetAlbum"); 719 719 + let path = http::uri::PathAndQuery::from_static( 720 720 + "/rockbox.v1alpha1.LibraryService/GetAlbum", 721 721 + ); 667 722 let mut req = request.into_request(); 668 668 - req.extensions_mut().insert(GrpcMethod::new( 669 669 - "rockbox.v1alpha1.LibraryService", 670 670 - "GetAlbum", 671 671 - )); 723 723 + req.extensions_mut() 724 724 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetAlbum")); 672 725 self.inner.unary(req, path, codec).await 673 726 } 674 727 pub async fn get_artist( 675 728 &mut self, 676 729 request: impl tonic::IntoRequest<super::GetArtistRequest>, 677 677 - ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status> { 678 678 - self.inner.ready().await.map_err(|e| { 679 679 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 680 680 - })?; 730 730 + ) -> std::result::Result< 731 731 + tonic::Response<super::GetArtistResponse>, 732 732 + tonic::Status, 733 733 + > { 734 734 + self.inner 735 735 + .ready() 736 736 + .await 737 737 + .map_err(|e| { 738 738 + tonic::Status::unknown( 739 739 + format!("Service was not ready: {}", e.into()), 740 740 + ) 741 741 + })?; 681 742 let codec = tonic::codec::ProstCodec::default(); 682 682 - let path = 683 683 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetArtist"); 743 743 + let path = http::uri::PathAndQuery::from_static( 744 744 + "/rockbox.v1alpha1.LibraryService/GetArtist", 745 745 + ); 684 746 let mut req = request.into_request(); 685 685 - req.extensions_mut().insert(GrpcMethod::new( 686 686 - "rockbox.v1alpha1.LibraryService", 687 687 - "GetArtist", 688 688 - )); 747 747 + req.extensions_mut() 748 748 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetArtist")); 689 749 self.inner.unary(req, path, codec).await 690 750 } 691 751 pub async fn get_track( 692 752 &mut self, 693 753 request: impl tonic::IntoRequest<super::GetTrackRequest>, 694 694 - ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status> { 695 695 - self.inner.ready().await.map_err(|e| { 696 696 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 697 697 - })?; 754 754 + ) -> std::result::Result< 755 755 + tonic::Response<super::GetTrackResponse>, 756 756 + tonic::Status, 757 757 + > { 758 758 + self.inner 759 759 + .ready() 760 760 + .await 761 761 + .map_err(|e| { 762 762 + tonic::Status::unknown( 763 763 + format!("Service was not ready: {}", e.into()), 764 764 + ) 765 765 + })?; 698 766 let codec = tonic::codec::ProstCodec::default(); 699 699 - let path = 700 700 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/GetTrack"); 767 767 + let path = http::uri::PathAndQuery::from_static( 768 768 + "/rockbox.v1alpha1.LibraryService/GetTrack", 769 769 + ); 701 770 let mut req = request.into_request(); 702 702 - req.extensions_mut().insert(GrpcMethod::new( 703 703 - "rockbox.v1alpha1.LibraryService", 704 704 - "GetTrack", 705 705 - )); 771 771 + req.extensions_mut() 772 772 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetTrack")); 706 773 self.inner.unary(req, path, codec).await 707 774 } 708 775 pub async fn like_track( 709 776 &mut self, 710 777 request: impl tonic::IntoRequest<super::LikeTrackRequest>, 711 711 - ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status> { 712 712 - self.inner.ready().await.map_err(|e| { 713 713 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 714 714 - })?; 778 778 + ) -> std::result::Result< 779 779 + tonic::Response<super::LikeTrackResponse>, 780 780 + tonic::Status, 781 781 + > { 782 782 + self.inner 783 783 + .ready() 784 784 + .await 785 785 + .map_err(|e| { 786 786 + tonic::Status::unknown( 787 787 + format!("Service was not ready: {}", e.into()), 788 788 + ) 789 789 + })?; 715 790 let codec = tonic::codec::ProstCodec::default(); 716 716 - let path = 717 717 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeTrack"); 791 791 + let path = http::uri::PathAndQuery::from_static( 792 792 + "/rockbox.v1alpha1.LibraryService/LikeTrack", 793 793 + ); 718 794 let mut req = request.into_request(); 719 719 - req.extensions_mut().insert(GrpcMethod::new( 720 720 - "rockbox.v1alpha1.LibraryService", 721 721 - "LikeTrack", 722 722 - )); 795 795 + req.extensions_mut() 796 796 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeTrack")); 723 797 self.inner.unary(req, path, codec).await 724 798 } 725 799 pub async fn unlike_track( 726 800 &mut self, 727 801 request: impl tonic::IntoRequest<super::UnlikeTrackRequest>, 728 728 - ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status> 729 729 - { 730 730 - self.inner.ready().await.map_err(|e| { 731 731 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 732 732 - })?; 802 802 + ) -> std::result::Result< 803 803 + tonic::Response<super::UnlikeTrackResponse>, 804 804 + tonic::Status, 805 805 + > { 806 806 + self.inner 807 807 + .ready() 808 808 + .await 809 809 + .map_err(|e| { 810 810 + tonic::Status::unknown( 811 811 + format!("Service was not ready: {}", e.into()), 812 812 + ) 813 813 + })?; 733 814 let codec = tonic::codec::ProstCodec::default(); 734 815 let path = http::uri::PathAndQuery::from_static( 735 816 "/rockbox.v1alpha1.LibraryService/UnlikeTrack", 736 817 ); 737 818 let mut req = request.into_request(); 738 738 - req.extensions_mut().insert(GrpcMethod::new( 739 739 - "rockbox.v1alpha1.LibraryService", 740 740 - "UnlikeTrack", 741 741 - )); 819 819 + req.extensions_mut() 820 820 + .insert( 821 821 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeTrack"), 822 822 + ); 742 823 self.inner.unary(req, path, codec).await 743 824 } 744 825 pub async fn like_album( 745 826 &mut self, 746 827 request: impl tonic::IntoRequest<super::LikeAlbumRequest>, 747 747 - ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status> { 748 748 - self.inner.ready().await.map_err(|e| { 749 749 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 750 750 - })?; 828 828 + ) -> std::result::Result< 829 829 + tonic::Response<super::LikeAlbumResponse>, 830 830 + tonic::Status, 831 831 + > { 832 832 + self.inner 833 833 + .ready() 834 834 + .await 835 835 + .map_err(|e| { 836 836 + tonic::Status::unknown( 837 837 + format!("Service was not ready: {}", e.into()), 838 838 + ) 839 839 + })?; 751 840 let codec = tonic::codec::ProstCodec::default(); 752 752 - let path = 753 753 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/LikeAlbum"); 841 841 + let path = http::uri::PathAndQuery::from_static( 842 842 + "/rockbox.v1alpha1.LibraryService/LikeAlbum", 843 843 + ); 754 844 let mut req = request.into_request(); 755 755 - req.extensions_mut().insert(GrpcMethod::new( 756 756 - "rockbox.v1alpha1.LibraryService", 757 757 - "LikeAlbum", 758 758 - )); 845 845 + req.extensions_mut() 846 846 + .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "LikeAlbum")); 759 847 self.inner.unary(req, path, codec).await 760 848 } 761 849 pub async fn unlike_album( 762 850 &mut self, 763 851 request: impl tonic::IntoRequest<super::UnlikeAlbumRequest>, 764 764 - ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status> 765 765 - { 766 766 - self.inner.ready().await.map_err(|e| { 767 767 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 768 768 - })?; 852 852 + ) -> std::result::Result< 853 853 + tonic::Response<super::UnlikeAlbumResponse>, 854 854 + tonic::Status, 855 855 + > { 856 856 + self.inner 857 857 + .ready() 858 858 + .await 859 859 + .map_err(|e| { 860 860 + tonic::Status::unknown( 861 861 + format!("Service was not ready: {}", e.into()), 862 862 + ) 863 863 + })?; 769 864 let codec = tonic::codec::ProstCodec::default(); 770 865 let path = http::uri::PathAndQuery::from_static( 771 866 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum", 772 867 ); 773 868 let mut req = request.into_request(); 774 774 - req.extensions_mut().insert(GrpcMethod::new( 775 775 - "rockbox.v1alpha1.LibraryService", 776 776 - "UnlikeAlbum", 777 777 - )); 869 869 + req.extensions_mut() 870 870 + .insert( 871 871 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "UnlikeAlbum"), 872 872 + ); 778 873 self.inner.unary(req, path, codec).await 779 874 } 780 875 pub async fn get_liked_tracks( 781 876 &mut self, 782 877 request: impl tonic::IntoRequest<super::GetLikedTracksRequest>, 783 783 - ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status> 784 784 - { 785 785 - self.inner.ready().await.map_err(|e| { 786 786 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 787 787 - })?; 878 878 + ) -> std::result::Result< 879 879 + tonic::Response<super::GetLikedTracksResponse>, 880 880 + tonic::Status, 881 881 + > { 882 882 + self.inner 883 883 + .ready() 884 884 + .await 885 885 + .map_err(|e| { 886 886 + tonic::Status::unknown( 887 887 + format!("Service was not ready: {}", e.into()), 888 888 + ) 889 889 + })?; 788 890 let codec = tonic::codec::ProstCodec::default(); 789 891 let path = http::uri::PathAndQuery::from_static( 790 892 "/rockbox.v1alpha1.LibraryService/GetLikedTracks", 791 893 ); 792 894 let mut req = request.into_request(); 793 793 - req.extensions_mut().insert(GrpcMethod::new( 794 794 - "rockbox.v1alpha1.LibraryService", 795 795 - "GetLikedTracks", 796 796 - )); 895 895 + req.extensions_mut() 896 896 + .insert( 897 897 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedTracks"), 898 898 + ); 797 899 self.inner.unary(req, path, codec).await 798 900 } 799 901 pub async fn get_liked_albums( 800 902 &mut self, 801 903 request: impl tonic::IntoRequest<super::GetLikedAlbumsRequest>, 802 802 - ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status> 803 803 - { 804 804 - self.inner.ready().await.map_err(|e| { 805 805 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 806 806 - })?; 904 904 + ) -> std::result::Result< 905 905 + tonic::Response<super::GetLikedAlbumsResponse>, 906 906 + tonic::Status, 907 907 + > { 908 908 + self.inner 909 909 + .ready() 910 910 + .await 911 911 + .map_err(|e| { 912 912 + tonic::Status::unknown( 913 913 + format!("Service was not ready: {}", e.into()), 914 914 + ) 915 915 + })?; 807 916 let codec = tonic::codec::ProstCodec::default(); 808 917 let path = http::uri::PathAndQuery::from_static( 809 918 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums", 810 919 ); 811 920 let mut req = request.into_request(); 812 812 - req.extensions_mut().insert(GrpcMethod::new( 813 813 - "rockbox.v1alpha1.LibraryService", 814 814 - "GetLikedAlbums", 815 815 - )); 921 921 + req.extensions_mut() 922 922 + .insert( 923 923 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "GetLikedAlbums"), 924 924 + ); 816 925 self.inner.unary(req, path, codec).await 817 926 } 818 927 pub async fn scan_library( 819 928 &mut self, 820 929 request: impl tonic::IntoRequest<super::ScanLibraryRequest>, 821 821 - ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status> 822 822 - { 823 823 - self.inner.ready().await.map_err(|e| { 824 824 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 825 825 - })?; 930 930 + ) -> std::result::Result< 931 931 + tonic::Response<super::ScanLibraryResponse>, 932 932 + tonic::Status, 933 933 + > { 934 934 + self.inner 935 935 + .ready() 936 936 + .await 937 937 + .map_err(|e| { 938 938 + tonic::Status::unknown( 939 939 + format!("Service was not ready: {}", e.into()), 940 940 + ) 941 941 + })?; 826 942 let codec = tonic::codec::ProstCodec::default(); 827 943 let path = http::uri::PathAndQuery::from_static( 828 944 "/rockbox.v1alpha1.LibraryService/ScanLibrary", 829 945 ); 830 946 let mut req = request.into_request(); 831 831 - req.extensions_mut().insert(GrpcMethod::new( 832 832 - "rockbox.v1alpha1.LibraryService", 833 833 - "ScanLibrary", 834 834 - )); 947 947 + req.extensions_mut() 948 948 + .insert( 949 949 + GrpcMethod::new("rockbox.v1alpha1.LibraryService", "ScanLibrary"), 950 950 + ); 835 951 self.inner.unary(req, path, codec).await 836 952 } 837 953 pub async fn search( 838 954 &mut self, 839 955 request: impl tonic::IntoRequest<super::SearchRequest>, 840 956 ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> { 841 841 - self.inner.ready().await.map_err(|e| { 842 842 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 843 843 - })?; 957 957 + self.inner 958 958 + .ready() 959 959 + .await 960 960 + .map_err(|e| { 961 961 + tonic::Status::unknown( 962 962 + format!("Service was not ready: {}", e.into()), 963 963 + ) 964 964 + })?; 844 965 let codec = tonic::codec::ProstCodec::default(); 845 845 - let path = 846 846 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.LibraryService/Search"); 966 966 + let path = http::uri::PathAndQuery::from_static( 967 967 + "/rockbox.v1alpha1.LibraryService/Search", 968 968 + ); 847 969 let mut req = request.into_request(); 848 970 req.extensions_mut() 849 971 .insert(GrpcMethod::new("rockbox.v1alpha1.LibraryService", "Search")); ··· 858 980 dead_code, 859 981 missing_docs, 860 982 clippy::wildcard_imports, 861 861 - clippy::let_unit_value 983 983 + clippy::let_unit_value, 862 984 )] 863 985 use tonic::codegen::*; 864 986 /// Generated trait containing gRPC methods that should be implemented for use with LibraryServiceServer. ··· 867 989 async fn get_albums( 868 990 &self, 869 991 request: tonic::Request<super::GetAlbumsRequest>, 870 870 - ) -> std::result::Result<tonic::Response<super::GetAlbumsResponse>, tonic::Status>; 992 992 + ) -> std::result::Result< 993 993 + tonic::Response<super::GetAlbumsResponse>, 994 994 + tonic::Status, 995 995 + >; 871 996 async fn get_artists( 872 997 &self, 873 998 request: tonic::Request<super::GetArtistsRequest>, 874 874 - ) -> std::result::Result<tonic::Response<super::GetArtistsResponse>, tonic::Status>; 999 999 + ) -> std::result::Result< 1000 1000 + tonic::Response<super::GetArtistsResponse>, 1001 1001 + tonic::Status, 1002 1002 + >; 875 1003 async fn get_tracks( 876 1004 &self, 877 1005 request: tonic::Request<super::GetTracksRequest>, 878 878 - ) -> std::result::Result<tonic::Response<super::GetTracksResponse>, tonic::Status>; 1006 1006 + ) -> std::result::Result< 1007 1007 + tonic::Response<super::GetTracksResponse>, 1008 1008 + tonic::Status, 1009 1009 + >; 879 1010 async fn get_album( 880 1011 &self, 881 1012 request: tonic::Request<super::GetAlbumRequest>, 882 882 - ) -> std::result::Result<tonic::Response<super::GetAlbumResponse>, tonic::Status>; 1013 1013 + ) -> std::result::Result< 1014 1014 + tonic::Response<super::GetAlbumResponse>, 1015 1015 + tonic::Status, 1016 1016 + >; 883 1017 async fn get_artist( 884 1018 &self, 885 1019 request: tonic::Request<super::GetArtistRequest>, 886 886 - ) -> std::result::Result<tonic::Response<super::GetArtistResponse>, tonic::Status>; 1020 1020 + ) -> std::result::Result< 1021 1021 + tonic::Response<super::GetArtistResponse>, 1022 1022 + tonic::Status, 1023 1023 + >; 887 1024 async fn get_track( 888 1025 &self, 889 1026 request: tonic::Request<super::GetTrackRequest>, 890 890 - ) -> std::result::Result<tonic::Response<super::GetTrackResponse>, tonic::Status>; 1027 1027 + ) -> std::result::Result< 1028 1028 + tonic::Response<super::GetTrackResponse>, 1029 1029 + tonic::Status, 1030 1030 + >; 891 1031 async fn like_track( 892 1032 &self, 893 1033 request: tonic::Request<super::LikeTrackRequest>, 894 894 - ) -> std::result::Result<tonic::Response<super::LikeTrackResponse>, tonic::Status>; 1034 1034 + ) -> std::result::Result< 1035 1035 + tonic::Response<super::LikeTrackResponse>, 1036 1036 + tonic::Status, 1037 1037 + >; 895 1038 async fn unlike_track( 896 1039 &self, 897 1040 request: tonic::Request<super::UnlikeTrackRequest>, 898 898 - ) -> std::result::Result<tonic::Response<super::UnlikeTrackResponse>, tonic::Status>; 1041 1041 + ) -> std::result::Result< 1042 1042 + tonic::Response<super::UnlikeTrackResponse>, 1043 1043 + tonic::Status, 1044 1044 + >; 899 1045 async fn like_album( 900 1046 &self, 901 1047 request: tonic::Request<super::LikeAlbumRequest>, 902 902 - ) -> std::result::Result<tonic::Response<super::LikeAlbumResponse>, tonic::Status>; 1048 1048 + ) -> std::result::Result< 1049 1049 + tonic::Response<super::LikeAlbumResponse>, 1050 1050 + tonic::Status, 1051 1051 + >; 903 1052 async fn unlike_album( 904 1053 &self, 905 1054 request: tonic::Request<super::UnlikeAlbumRequest>, 906 906 - ) -> std::result::Result<tonic::Response<super::UnlikeAlbumResponse>, tonic::Status>; 1055 1055 + ) -> std::result::Result< 1056 1056 + tonic::Response<super::UnlikeAlbumResponse>, 1057 1057 + tonic::Status, 1058 1058 + >; 907 1059 async fn get_liked_tracks( 908 1060 &self, 909 1061 request: tonic::Request<super::GetLikedTracksRequest>, 910 910 - ) -> std::result::Result<tonic::Response<super::GetLikedTracksResponse>, tonic::Status>; 1062 1062 + ) -> std::result::Result< 1063 1063 + tonic::Response<super::GetLikedTracksResponse>, 1064 1064 + tonic::Status, 1065 1065 + >; 911 1066 async fn get_liked_albums( 912 1067 &self, 913 1068 request: tonic::Request<super::GetLikedAlbumsRequest>, 914 914 - ) -> std::result::Result<tonic::Response<super::GetLikedAlbumsResponse>, tonic::Status>; 1069 1069 + ) -> std::result::Result< 1070 1070 + tonic::Response<super::GetLikedAlbumsResponse>, 1071 1071 + tonic::Status, 1072 1072 + >; 915 1073 async fn scan_library( 916 1074 &self, 917 1075 request: tonic::Request<super::ScanLibraryRequest>, 918 918 - ) -> std::result::Result<tonic::Response<super::ScanLibraryResponse>, tonic::Status>; 1076 1076 + ) -> std::result::Result< 1077 1077 + tonic::Response<super::ScanLibraryResponse>, 1078 1078 + tonic::Status, 1079 1079 + >; 919 1080 async fn search( 920 1081 &self, 921 1082 request: tonic::Request<super::SearchRequest>, ··· 942 1103 max_encoding_message_size: None, 943 1104 } 944 1105 } 945 945 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1106 1106 + pub fn with_interceptor<F>( 1107 1107 + inner: T, 1108 1108 + interceptor: F, 1109 1109 + ) -> InterceptedService<Self, F> 946 1110 where 947 1111 F: tonic::service::Interceptor, 948 1112 { ··· 997 1161 "/rockbox.v1alpha1.LibraryService/GetAlbums" => { 998 1162 #[allow(non_camel_case_types)] 999 1163 struct GetAlbumsSvc<T: LibraryService>(pub Arc<T>); 1000 1000 - impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumsRequest> for GetAlbumsSvc<T> { 1164 1164 + impl< 1165 1165 + T: LibraryService, 1166 1166 + > tonic::server::UnaryService<super::GetAlbumsRequest> 1167 1167 + for GetAlbumsSvc<T> { 1001 1168 type Response = super::GetAlbumsResponse; 1002 1002 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1169 1169 + type Future = BoxFuture< 1170 1170 + tonic::Response<Self::Response>, 1171 1171 + tonic::Status, 1172 1172 + >; 1003 1173 fn call( 1004 1174 &mut self, 1005 1175 request: tonic::Request<super::GetAlbumsRequest>, ··· 1036 1206 "/rockbox.v1alpha1.LibraryService/GetArtists" => { 1037 1207 #[allow(non_camel_case_types)] 1038 1208 struct GetArtistsSvc<T: LibraryService>(pub Arc<T>); 1039 1039 - impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistsRequest> for GetArtistsSvc<T> { 1209 1209 + impl< 1210 1210 + T: LibraryService, 1211 1211 + > tonic::server::UnaryService<super::GetArtistsRequest> 1212 1212 + for GetArtistsSvc<T> { 1040 1213 type Response = super::GetArtistsResponse; 1041 1041 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1214 1214 + type Future = BoxFuture< 1215 1215 + tonic::Response<Self::Response>, 1216 1216 + tonic::Status, 1217 1217 + >; 1042 1218 fn call( 1043 1219 &mut self, 1044 1220 request: tonic::Request<super::GetArtistsRequest>, ··· 1075 1251 "/rockbox.v1alpha1.LibraryService/GetTracks" => { 1076 1252 #[allow(non_camel_case_types)] 1077 1253 struct GetTracksSvc<T: LibraryService>(pub Arc<T>); 1078 1078 - impl<T: LibraryService> tonic::server::UnaryService<super::GetTracksRequest> for GetTracksSvc<T> { 1254 1254 + impl< 1255 1255 + T: LibraryService, 1256 1256 + > tonic::server::UnaryService<super::GetTracksRequest> 1257 1257 + for GetTracksSvc<T> { 1079 1258 type Response = super::GetTracksResponse; 1080 1080 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1259 1259 + type Future = BoxFuture< 1260 1260 + tonic::Response<Self::Response>, 1261 1261 + tonic::Status, 1262 1262 + >; 1081 1263 fn call( 1082 1264 &mut self, 1083 1265 request: tonic::Request<super::GetTracksRequest>, ··· 1114 1296 "/rockbox.v1alpha1.LibraryService/GetAlbum" => { 1115 1297 #[allow(non_camel_case_types)] 1116 1298 struct GetAlbumSvc<T: LibraryService>(pub Arc<T>); 1117 1117 - impl<T: LibraryService> tonic::server::UnaryService<super::GetAlbumRequest> for GetAlbumSvc<T> { 1299 1299 + impl< 1300 1300 + T: LibraryService, 1301 1301 + > tonic::server::UnaryService<super::GetAlbumRequest> 1302 1302 + for GetAlbumSvc<T> { 1118 1303 type Response = super::GetAlbumResponse; 1119 1119 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1304 1304 + type Future = BoxFuture< 1305 1305 + tonic::Response<Self::Response>, 1306 1306 + tonic::Status, 1307 1307 + >; 1120 1308 fn call( 1121 1309 &mut self, 1122 1310 request: tonic::Request<super::GetAlbumRequest>, ··· 1153 1341 "/rockbox.v1alpha1.LibraryService/GetArtist" => { 1154 1342 #[allow(non_camel_case_types)] 1155 1343 struct GetArtistSvc<T: LibraryService>(pub Arc<T>); 1156 1156 - impl<T: LibraryService> tonic::server::UnaryService<super::GetArtistRequest> for GetArtistSvc<T> { 1344 1344 + impl< 1345 1345 + T: LibraryService, 1346 1346 + > tonic::server::UnaryService<super::GetArtistRequest> 1347 1347 + for GetArtistSvc<T> { 1157 1348 type Response = super::GetArtistResponse; 1158 1158 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1349 1349 + type Future = BoxFuture< 1350 1350 + tonic::Response<Self::Response>, 1351 1351 + tonic::Status, 1352 1352 + >; 1159 1353 fn call( 1160 1354 &mut self, 1161 1355 request: tonic::Request<super::GetArtistRequest>, ··· 1192 1386 "/rockbox.v1alpha1.LibraryService/GetTrack" => { 1193 1387 #[allow(non_camel_case_types)] 1194 1388 struct GetTrackSvc<T: LibraryService>(pub Arc<T>); 1195 1195 - impl<T: LibraryService> tonic::server::UnaryService<super::GetTrackRequest> for GetTrackSvc<T> { 1389 1389 + impl< 1390 1390 + T: LibraryService, 1391 1391 + > tonic::server::UnaryService<super::GetTrackRequest> 1392 1392 + for GetTrackSvc<T> { 1196 1393 type Response = super::GetTrackResponse; 1197 1197 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1394 1394 + type Future = BoxFuture< 1395 1395 + tonic::Response<Self::Response>, 1396 1396 + tonic::Status, 1397 1397 + >; 1198 1398 fn call( 1199 1399 &mut self, 1200 1400 request: tonic::Request<super::GetTrackRequest>, ··· 1231 1431 "/rockbox.v1alpha1.LibraryService/LikeTrack" => { 1232 1432 #[allow(non_camel_case_types)] 1233 1433 struct LikeTrackSvc<T: LibraryService>(pub Arc<T>); 1234 1234 - impl<T: LibraryService> tonic::server::UnaryService<super::LikeTrackRequest> for LikeTrackSvc<T> { 1434 1434 + impl< 1435 1435 + T: LibraryService, 1436 1436 + > tonic::server::UnaryService<super::LikeTrackRequest> 1437 1437 + for LikeTrackSvc<T> { 1235 1438 type Response = super::LikeTrackResponse; 1236 1236 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1439 1439 + type Future = BoxFuture< 1440 1440 + tonic::Response<Self::Response>, 1441 1441 + tonic::Status, 1442 1442 + >; 1237 1443 fn call( 1238 1444 &mut self, 1239 1445 request: tonic::Request<super::LikeTrackRequest>, ··· 1270 1476 "/rockbox.v1alpha1.LibraryService/UnlikeTrack" => { 1271 1477 #[allow(non_camel_case_types)] 1272 1478 struct UnlikeTrackSvc<T: LibraryService>(pub Arc<T>); 1273 1273 - impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeTrackRequest> 1274 1274 - for UnlikeTrackSvc<T> 1275 1275 - { 1479 1479 + impl< 1480 1480 + T: LibraryService, 1481 1481 + > tonic::server::UnaryService<super::UnlikeTrackRequest> 1482 1482 + for UnlikeTrackSvc<T> { 1276 1483 type Response = super::UnlikeTrackResponse; 1277 1277 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1484 1484 + type Future = BoxFuture< 1485 1485 + tonic::Response<Self::Response>, 1486 1486 + tonic::Status, 1487 1487 + >; 1278 1488 fn call( 1279 1489 &mut self, 1280 1490 request: tonic::Request<super::UnlikeTrackRequest>, ··· 1311 1521 "/rockbox.v1alpha1.LibraryService/LikeAlbum" => { 1312 1522 #[allow(non_camel_case_types)] 1313 1523 struct LikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1314 1314 - impl<T: LibraryService> tonic::server::UnaryService<super::LikeAlbumRequest> for LikeAlbumSvc<T> { 1524 1524 + impl< 1525 1525 + T: LibraryService, 1526 1526 + > tonic::server::UnaryService<super::LikeAlbumRequest> 1527 1527 + for LikeAlbumSvc<T> { 1315 1528 type Response = super::LikeAlbumResponse; 1316 1316 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1529 1529 + type Future = BoxFuture< 1530 1530 + tonic::Response<Self::Response>, 1531 1531 + tonic::Status, 1532 1532 + >; 1317 1533 fn call( 1318 1534 &mut self, 1319 1535 request: tonic::Request<super::LikeAlbumRequest>, ··· 1350 1566 "/rockbox.v1alpha1.LibraryService/UnlikeAlbum" => { 1351 1567 #[allow(non_camel_case_types)] 1352 1568 struct UnlikeAlbumSvc<T: LibraryService>(pub Arc<T>); 1353 1353 - impl<T: LibraryService> tonic::server::UnaryService<super::UnlikeAlbumRequest> 1354 1354 - for UnlikeAlbumSvc<T> 1355 1355 - { 1569 1569 + impl< 1570 1570 + T: LibraryService, 1571 1571 + > tonic::server::UnaryService<super::UnlikeAlbumRequest> 1572 1572 + for UnlikeAlbumSvc<T> { 1356 1573 type Response = super::UnlikeAlbumResponse; 1357 1357 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1574 1574 + type Future = BoxFuture< 1575 1575 + tonic::Response<Self::Response>, 1576 1576 + tonic::Status, 1577 1577 + >; 1358 1578 fn call( 1359 1579 &mut self, 1360 1580 request: tonic::Request<super::UnlikeAlbumRequest>, ··· 1391 1611 "/rockbox.v1alpha1.LibraryService/GetLikedTracks" => { 1392 1612 #[allow(non_camel_case_types)] 1393 1613 struct GetLikedTracksSvc<T: LibraryService>(pub Arc<T>); 1394 1394 - impl<T: LibraryService> 1395 1395 - tonic::server::UnaryService<super::GetLikedTracksRequest> 1396 1396 - for GetLikedTracksSvc<T> 1397 1397 - { 1614 1614 + impl< 1615 1615 + T: LibraryService, 1616 1616 + > tonic::server::UnaryService<super::GetLikedTracksRequest> 1617 1617 + for GetLikedTracksSvc<T> { 1398 1618 type Response = super::GetLikedTracksResponse; 1399 1399 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1619 1619 + type Future = BoxFuture< 1620 1620 + tonic::Response<Self::Response>, 1621 1621 + tonic::Status, 1622 1622 + >; 1400 1623 fn call( 1401 1624 &mut self, 1402 1625 request: tonic::Request<super::GetLikedTracksRequest>, 1403 1626 ) -> Self::Future { 1404 1627 let inner = Arc::clone(&self.0); 1405 1628 let fut = async move { 1406 1406 - <T as LibraryService>::get_liked_tracks(&inner, request).await 1629 1629 + <T as LibraryService>::get_liked_tracks(&inner, request) 1630 1630 + .await 1407 1631 }; 1408 1632 Box::pin(fut) 1409 1633 } ··· 1433 1657 "/rockbox.v1alpha1.LibraryService/GetLikedAlbums" => { 1434 1658 #[allow(non_camel_case_types)] 1435 1659 struct GetLikedAlbumsSvc<T: LibraryService>(pub Arc<T>); 1436 1436 - impl<T: LibraryService> 1437 1437 - tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1438 1438 - for GetLikedAlbumsSvc<T> 1439 1439 - { 1660 1660 + impl< 1661 1661 + T: LibraryService, 1662 1662 + > tonic::server::UnaryService<super::GetLikedAlbumsRequest> 1663 1663 + for GetLikedAlbumsSvc<T> { 1440 1664 type Response = super::GetLikedAlbumsResponse; 1441 1441 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1665 1665 + type Future = BoxFuture< 1666 1666 + tonic::Response<Self::Response>, 1667 1667 + tonic::Status, 1668 1668 + >; 1442 1669 fn call( 1443 1670 &mut self, 1444 1671 request: tonic::Request<super::GetLikedAlbumsRequest>, 1445 1672 ) -> Self::Future { 1446 1673 let inner = Arc::clone(&self.0); 1447 1674 let fut = async move { 1448 1448 - <T as LibraryService>::get_liked_albums(&inner, request).await 1675 1675 + <T as LibraryService>::get_liked_albums(&inner, request) 1676 1676 + .await 1449 1677 }; 1450 1678 Box::pin(fut) 1451 1679 } ··· 1475 1703 "/rockbox.v1alpha1.LibraryService/ScanLibrary" => { 1476 1704 #[allow(non_camel_case_types)] 1477 1705 struct ScanLibrarySvc<T: LibraryService>(pub Arc<T>); 1478 1478 - impl<T: LibraryService> tonic::server::UnaryService<super::ScanLibraryRequest> 1479 1479 - for ScanLibrarySvc<T> 1480 1480 - { 1706 1706 + impl< 1707 1707 + T: LibraryService, 1708 1708 + > tonic::server::UnaryService<super::ScanLibraryRequest> 1709 1709 + for ScanLibrarySvc<T> { 1481 1710 type Response = super::ScanLibraryResponse; 1482 1482 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1711 1711 + type Future = BoxFuture< 1712 1712 + tonic::Response<Self::Response>, 1713 1713 + tonic::Status, 1714 1714 + >; 1483 1715 fn call( 1484 1716 &mut self, 1485 1717 request: tonic::Request<super::ScanLibraryRequest>, ··· 1516 1748 "/rockbox.v1alpha1.LibraryService/Search" => { 1517 1749 #[allow(non_camel_case_types)] 1518 1750 struct SearchSvc<T: LibraryService>(pub Arc<T>); 1519 1519 - impl<T: LibraryService> tonic::server::UnaryService<super::SearchRequest> for SearchSvc<T> { 1751 1751 + impl< 1752 1752 + T: LibraryService, 1753 1753 + > tonic::server::UnaryService<super::SearchRequest> 1754 1754 + for SearchSvc<T> { 1520 1755 type Response = super::SearchResponse; 1521 1521 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 1756 1756 + type Future = BoxFuture< 1757 1757 + tonic::Response<Self::Response>, 1758 1758 + tonic::Status, 1759 1759 + >; 1522 1760 fn call( 1523 1761 &mut self, 1524 1762 request: tonic::Request<super::SearchRequest>, 1525 1763 ) -> Self::Future { 1526 1764 let inner = Arc::clone(&self.0); 1527 1527 - let fut = 1528 1528 - async move { <T as LibraryService>::search(&inner, request).await }; 1765 1765 + let fut = async move { 1766 1766 + <T as LibraryService>::search(&inner, request).await 1767 1767 + }; 1529 1768 Box::pin(fut) 1530 1769 } 1531 1770 } ··· 1551 1790 }; 1552 1791 Box::pin(fut) 1553 1792 } 1554 1554 - _ => Box::pin(async move { 1555 1555 - let mut response = http::Response::new(empty_body()); 1556 1556 - let headers = response.headers_mut(); 1557 1557 - headers.insert( 1558 1558 - tonic::Status::GRPC_STATUS, 1559 1559 - (tonic::Code::Unimplemented as i32).into(), 1560 1560 - ); 1561 1561 - headers.insert( 1562 1562 - http::header::CONTENT_TYPE, 1563 1563 - tonic::metadata::GRPC_CONTENT_TYPE, 1564 1564 - ); 1565 1565 - Ok(response) 1566 1566 - }), 1793 1793 + _ => { 1794 1794 + Box::pin(async move { 1795 1795 + let mut response = http::Response::new(empty_body()); 1796 1796 + let headers = response.headers_mut(); 1797 1797 + headers 1798 1798 + .insert( 1799 1799 + tonic::Status::GRPC_STATUS, 1800 1800 + (tonic::Code::Unimplemented as i32).into(), 1801 1801 + ); 1802 1802 + headers 1803 1803 + .insert( 1804 1804 + http::header::CONTENT_TYPE, 1805 1805 + tonic::metadata::GRPC_CONTENT_TYPE, 1806 1806 + ); 1807 1807 + Ok(response) 1808 1808 + }) 1809 1809 + } 1567 1810 } 1568 1811 } 1569 1812 } ··· 1592 1835 dead_code, 1593 1836 missing_docs, 1594 1837 clippy::wildcard_imports, 1595 1595 - clippy::let_unit_value 1838 1838 + clippy::let_unit_value, 1596 1839 )] 1597 1597 - use tonic::codegen::http::Uri; 1598 1840 use tonic::codegen::*; 1841 1841 + use tonic::codegen::http::Uri; 1599 1842 #[derive(Debug, Clone)] 1600 1843 pub struct MetadataServiceClient<T> { 1601 1844 inner: tonic::client::Grpc<T>, ··· 1639 1882 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 1640 1883 >, 1641 1884 >, 1642 1642 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 1643 1643 - Into<StdError> + std::marker::Send + std::marker::Sync, 1885 1885 + <T as tonic::codegen::Service< 1886 1886 + http::Request<tonic::body::BoxBody>, 1887 1887 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 1644 1888 { 1645 1889 MetadataServiceClient::new(InterceptedService::new(inner, interceptor)) 1646 1890 } ··· 1684 1928 dead_code, 1685 1929 missing_docs, 1686 1930 clippy::wildcard_imports, 1687 1687 - clippy::let_unit_value 1931 1931 + clippy::let_unit_value, 1688 1932 )] 1689 1933 use tonic::codegen::*; 1690 1934 /// Generated trait containing gRPC methods that should be implemented for use with MetadataServiceServer. ··· 1711 1955 max_encoding_message_size: None, 1712 1956 } 1713 1957 } 1714 1714 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 1958 1958 + pub fn with_interceptor<F>( 1959 1959 + inner: T, 1960 1960 + interceptor: F, 1961 1961 + ) -> InterceptedService<Self, F> 1715 1962 where 1716 1963 F: tonic::service::Interceptor, 1717 1964 { ··· 1763 2010 } 1764 2011 fn call(&mut self, req: http::Request<B>) -> Self::Future { 1765 2012 match req.uri().path() { 1766 1766 - _ => Box::pin(async move { 1767 1767 - let mut response = http::Response::new(empty_body()); 1768 1768 - let headers = response.headers_mut(); 1769 1769 - headers.insert( 1770 1770 - tonic::Status::GRPC_STATUS, 1771 1771 - (tonic::Code::Unimplemented as i32).into(), 1772 1772 - ); 1773 1773 - headers.insert( 1774 1774 - http::header::CONTENT_TYPE, 1775 1775 - tonic::metadata::GRPC_CONTENT_TYPE, 1776 1776 - ); 1777 1777 - Ok(response) 1778 1778 - }), 2013 2013 + _ => { 2014 2014 + Box::pin(async move { 2015 2015 + let mut response = http::Response::new(empty_body()); 2016 2016 + let headers = response.headers_mut(); 2017 2017 + headers 2018 2018 + .insert( 2019 2019 + tonic::Status::GRPC_STATUS, 2020 2020 + (tonic::Code::Unimplemented as i32).into(), 2021 2021 + ); 2022 2022 + headers 2023 2023 + .insert( 2024 2024 + http::header::CONTENT_TYPE, 2025 2025 + tonic::metadata::GRPC_CONTENT_TYPE, 2026 2026 + ); 2027 2027 + Ok(response) 2028 2028 + }) 2029 2029 + } 1779 2030 } 1780 2031 } 1781 2032 } ··· 2044 2295 dead_code, 2045 2296 missing_docs, 2046 2297 clippy::wildcard_imports, 2047 2047 - clippy::let_unit_value 2298 2298 + clippy::let_unit_value, 2048 2299 )] 2049 2049 - use tonic::codegen::http::Uri; 2050 2300 use tonic::codegen::*; 2301 2301 + use tonic::codegen::http::Uri; 2051 2302 #[derive(Debug, Clone)] 2052 2303 pub struct PlaybackServiceClient<T> { 2053 2304 inner: tonic::client::Grpc<T>, ··· 2091 2342 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 2092 2343 >, 2093 2344 >, 2094 2094 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 2095 2095 - Into<StdError> + std::marker::Send + std::marker::Sync, 2345 2345 + <T as tonic::codegen::Service< 2346 2346 + http::Request<tonic::body::BoxBody>, 2347 2347 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 2096 2348 { 2097 2349 PlaybackServiceClient::new(InterceptedService::new(inner, interceptor)) 2098 2350 } ··· 2131 2383 &mut self, 2132 2384 request: impl tonic::IntoRequest<super::PlayRequest>, 2133 2385 ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> { 2134 2134 - self.inner.ready().await.map_err(|e| { 2135 2135 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2136 2136 - })?; 2386 2386 + self.inner 2387 2387 + .ready() 2388 2388 + .await 2389 2389 + .map_err(|e| { 2390 2390 + tonic::Status::unknown( 2391 2391 + format!("Service was not ready: {}", e.into()), 2392 2392 + ) 2393 2393 + })?; 2137 2394 let codec = tonic::codec::ProstCodec::default(); 2138 2138 - let path = 2139 2139 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Play"); 2395 2395 + let path = http::uri::PathAndQuery::from_static( 2396 2396 + "/rockbox.v1alpha1.PlaybackService/Play", 2397 2397 + ); 2140 2398 let mut req = request.into_request(); 2141 2399 req.extensions_mut() 2142 2400 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Play")); ··· 2146 2404 &mut self, 2147 2405 request: impl tonic::IntoRequest<super::PauseRequest>, 2148 2406 ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> { 2149 2149 - self.inner.ready().await.map_err(|e| { 2150 2150 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2151 2151 - })?; 2407 2407 + self.inner 2408 2408 + .ready() 2409 2409 + .await 2410 2410 + .map_err(|e| { 2411 2411 + tonic::Status::unknown( 2412 2412 + format!("Service was not ready: {}", e.into()), 2413 2413 + ) 2414 2414 + })?; 2152 2415 let codec = tonic::codec::ProstCodec::default(); 2153 2153 - let path = 2154 2154 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Pause"); 2416 2416 + let path = http::uri::PathAndQuery::from_static( 2417 2417 + "/rockbox.v1alpha1.PlaybackService/Pause", 2418 2418 + ); 2155 2419 let mut req = request.into_request(); 2156 2420 req.extensions_mut() 2157 2421 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Pause")); ··· 2161 2425 &mut self, 2162 2426 request: impl tonic::IntoRequest<super::ResumeRequest>, 2163 2427 ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> { 2164 2164 - self.inner.ready().await.map_err(|e| { 2165 2165 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2166 2166 - })?; 2428 2428 + self.inner 2429 2429 + .ready() 2430 2430 + .await 2431 2431 + .map_err(|e| { 2432 2432 + tonic::Status::unknown( 2433 2433 + format!("Service was not ready: {}", e.into()), 2434 2434 + ) 2435 2435 + })?; 2167 2436 let codec = tonic::codec::ProstCodec::default(); 2168 2168 - let path = 2169 2169 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Resume"); 2437 2437 + let path = http::uri::PathAndQuery::from_static( 2438 2438 + "/rockbox.v1alpha1.PlaybackService/Resume", 2439 2439 + ); 2170 2440 let mut req = request.into_request(); 2171 2171 - req.extensions_mut().insert(GrpcMethod::new( 2172 2172 - "rockbox.v1alpha1.PlaybackService", 2173 2173 - "Resume", 2174 2174 - )); 2441 2441 + req.extensions_mut() 2442 2442 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Resume")); 2175 2443 self.inner.unary(req, path, codec).await 2176 2444 } 2177 2445 pub async fn next( 2178 2446 &mut self, 2179 2447 request: impl tonic::IntoRequest<super::NextRequest>, 2180 2448 ) -> std::result::Result<tonic::Response<super::NextResponse>, tonic::Status> { 2181 2181 - self.inner.ready().await.map_err(|e| { 2182 2182 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2183 2183 - })?; 2449 2449 + self.inner 2450 2450 + .ready() 2451 2451 + .await 2452 2452 + .map_err(|e| { 2453 2453 + tonic::Status::unknown( 2454 2454 + format!("Service was not ready: {}", e.into()), 2455 2455 + ) 2456 2456 + })?; 2184 2457 let codec = tonic::codec::ProstCodec::default(); 2185 2185 - let path = 2186 2186 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Next"); 2458 2458 + let path = http::uri::PathAndQuery::from_static( 2459 2459 + "/rockbox.v1alpha1.PlaybackService/Next", 2460 2460 + ); 2187 2461 let mut req = request.into_request(); 2188 2462 req.extensions_mut() 2189 2463 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Next")); ··· 2192 2466 pub async fn previous( 2193 2467 &mut self, 2194 2468 request: impl tonic::IntoRequest<super::PreviousRequest>, 2195 2195 - ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status> { 2196 2196 - self.inner.ready().await.map_err(|e| { 2197 2197 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2198 2198 - })?; 2469 2469 + ) -> std::result::Result< 2470 2470 + tonic::Response<super::PreviousResponse>, 2471 2471 + tonic::Status, 2472 2472 + > { 2473 2473 + self.inner 2474 2474 + .ready() 2475 2475 + .await 2476 2476 + .map_err(|e| { 2477 2477 + tonic::Status::unknown( 2478 2478 + format!("Service was not ready: {}", e.into()), 2479 2479 + ) 2480 2480 + })?; 2199 2481 let codec = tonic::codec::ProstCodec::default(); 2200 2200 - let path = 2201 2201 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Previous"); 2482 2482 + let path = http::uri::PathAndQuery::from_static( 2483 2483 + "/rockbox.v1alpha1.PlaybackService/Previous", 2484 2484 + ); 2202 2485 let mut req = request.into_request(); 2203 2203 - req.extensions_mut().insert(GrpcMethod::new( 2204 2204 - "rockbox.v1alpha1.PlaybackService", 2205 2205 - "Previous", 2206 2206 - )); 2486 2486 + req.extensions_mut() 2487 2487 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Previous")); 2207 2488 self.inner.unary(req, path, codec).await 2208 2489 } 2209 2490 pub async fn fast_forward_rewind( 2210 2491 &mut self, 2211 2492 request: impl tonic::IntoRequest<super::FastForwardRewindRequest>, 2212 2212 - ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status> 2213 2213 - { 2214 2214 - self.inner.ready().await.map_err(|e| { 2215 2215 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2216 2216 - })?; 2493 2493 + ) -> std::result::Result< 2494 2494 + tonic::Response<super::FastForwardRewindResponse>, 2495 2495 + tonic::Status, 2496 2496 + > { 2497 2497 + self.inner 2498 2498 + .ready() 2499 2499 + .await 2500 2500 + .map_err(|e| { 2501 2501 + tonic::Status::unknown( 2502 2502 + format!("Service was not ready: {}", e.into()), 2503 2503 + ) 2504 2504 + })?; 2217 2505 let codec = tonic::codec::ProstCodec::default(); 2218 2506 let path = http::uri::PathAndQuery::from_static( 2219 2507 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind", 2220 2508 ); 2221 2509 let mut req = request.into_request(); 2222 2222 - req.extensions_mut().insert(GrpcMethod::new( 2223 2223 - "rockbox.v1alpha1.PlaybackService", 2224 2224 - "FastForwardRewind", 2225 2225 - )); 2510 2510 + req.extensions_mut() 2511 2511 + .insert( 2512 2512 + GrpcMethod::new( 2513 2513 + "rockbox.v1alpha1.PlaybackService", 2514 2514 + "FastForwardRewind", 2515 2515 + ), 2516 2516 + ); 2226 2517 self.inner.unary(req, path, codec).await 2227 2518 } 2228 2519 pub async fn status( 2229 2520 &mut self, 2230 2521 request: impl tonic::IntoRequest<super::StatusRequest>, 2231 2522 ) -> std::result::Result<tonic::Response<super::StatusResponse>, tonic::Status> { 2232 2232 - self.inner.ready().await.map_err(|e| { 2233 2233 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2234 2234 - })?; 2523 2523 + self.inner 2524 2524 + .ready() 2525 2525 + .await 2526 2526 + .map_err(|e| { 2527 2527 + tonic::Status::unknown( 2528 2528 + format!("Service was not ready: {}", e.into()), 2529 2529 + ) 2530 2530 + })?; 2235 2531 let codec = tonic::codec::ProstCodec::default(); 2236 2236 - let path = 2237 2237 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/Status"); 2532 2532 + let path = http::uri::PathAndQuery::from_static( 2533 2533 + "/rockbox.v1alpha1.PlaybackService/Status", 2534 2534 + ); 2238 2535 let mut req = request.into_request(); 2239 2239 - req.extensions_mut().insert(GrpcMethod::new( 2240 2240 - "rockbox.v1alpha1.PlaybackService", 2241 2241 - "Status", 2242 2242 - )); 2536 2536 + req.extensions_mut() 2537 2537 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "Status")); 2243 2538 self.inner.unary(req, path, codec).await 2244 2539 } 2245 2540 pub async fn current_track( 2246 2541 &mut self, 2247 2542 request: impl tonic::IntoRequest<super::CurrentTrackRequest>, 2248 2248 - ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status> 2249 2249 - { 2250 2250 - self.inner.ready().await.map_err(|e| { 2251 2251 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2252 2252 - })?; 2543 2543 + ) -> std::result::Result< 2544 2544 + tonic::Response<super::CurrentTrackResponse>, 2545 2545 + tonic::Status, 2546 2546 + > { 2547 2547 + self.inner 2548 2548 + .ready() 2549 2549 + .await 2550 2550 + .map_err(|e| { 2551 2551 + tonic::Status::unknown( 2552 2552 + format!("Service was not ready: {}", e.into()), 2553 2553 + ) 2554 2554 + })?; 2253 2555 let codec = tonic::codec::ProstCodec::default(); 2254 2556 let path = http::uri::PathAndQuery::from_static( 2255 2557 "/rockbox.v1alpha1.PlaybackService/CurrentTrack", 2256 2558 ); 2257 2559 let mut req = request.into_request(); 2258 2258 - req.extensions_mut().insert(GrpcMethod::new( 2259 2259 - "rockbox.v1alpha1.PlaybackService", 2260 2260 - "CurrentTrack", 2261 2261 - )); 2560 2560 + req.extensions_mut() 2561 2561 + .insert( 2562 2562 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "CurrentTrack"), 2563 2563 + ); 2262 2564 self.inner.unary(req, path, codec).await 2263 2565 } 2264 2566 pub async fn next_track( 2265 2567 &mut self, 2266 2568 request: impl tonic::IntoRequest<super::NextTrackRequest>, 2267 2267 - ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status> { 2268 2268 - self.inner.ready().await.map_err(|e| { 2269 2269 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2270 2270 - })?; 2569 2569 + ) -> std::result::Result< 2570 2570 + tonic::Response<super::NextTrackResponse>, 2571 2571 + tonic::Status, 2572 2572 + > { 2573 2573 + self.inner 2574 2574 + .ready() 2575 2575 + .await 2576 2576 + .map_err(|e| { 2577 2577 + tonic::Status::unknown( 2578 2578 + format!("Service was not ready: {}", e.into()), 2579 2579 + ) 2580 2580 + })?; 2271 2581 let codec = tonic::codec::ProstCodec::default(); 2272 2272 - let path = 2273 2273 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/NextTrack"); 2582 2582 + let path = http::uri::PathAndQuery::from_static( 2583 2583 + "/rockbox.v1alpha1.PlaybackService/NextTrack", 2584 2584 + ); 2274 2585 let mut req = request.into_request(); 2275 2275 - req.extensions_mut().insert(GrpcMethod::new( 2276 2276 - "rockbox.v1alpha1.PlaybackService", 2277 2277 - "NextTrack", 2278 2278 - )); 2586 2586 + req.extensions_mut() 2587 2587 + .insert( 2588 2588 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "NextTrack"), 2589 2589 + ); 2279 2590 self.inner.unary(req, path, codec).await 2280 2591 } 2281 2592 pub async fn flush_and_reload_tracks( 2282 2593 &mut self, 2283 2594 request: impl tonic::IntoRequest<super::FlushAndReloadTracksRequest>, 2284 2284 - ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status> 2285 2285 - { 2286 2286 - self.inner.ready().await.map_err(|e| { 2287 2287 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2288 2288 - })?; 2595 2595 + ) -> std::result::Result< 2596 2596 + tonic::Response<super::FlushAndReloadTracksResponse>, 2597 2597 + tonic::Status, 2598 2598 + > { 2599 2599 + self.inner 2600 2600 + .ready() 2601 2601 + .await 2602 2602 + .map_err(|e| { 2603 2603 + tonic::Status::unknown( 2604 2604 + format!("Service was not ready: {}", e.into()), 2605 2605 + ) 2606 2606 + })?; 2289 2607 let codec = tonic::codec::ProstCodec::default(); 2290 2608 let path = http::uri::PathAndQuery::from_static( 2291 2609 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks", 2292 2610 ); 2293 2611 let mut req = request.into_request(); 2294 2294 - req.extensions_mut().insert(GrpcMethod::new( 2295 2295 - "rockbox.v1alpha1.PlaybackService", 2296 2296 - "FlushAndReloadTracks", 2297 2297 - )); 2612 2612 + req.extensions_mut() 2613 2613 + .insert( 2614 2614 + GrpcMethod::new( 2615 2615 + "rockbox.v1alpha1.PlaybackService", 2616 2616 + "FlushAndReloadTracks", 2617 2617 + ), 2618 2618 + ); 2298 2619 self.inner.unary(req, path, codec).await 2299 2620 } 2300 2621 pub async fn get_file_position( 2301 2622 &mut self, 2302 2623 request: impl tonic::IntoRequest<super::GetFilePositionRequest>, 2303 2303 - ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status> 2304 2304 - { 2305 2305 - self.inner.ready().await.map_err(|e| { 2306 2306 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2307 2307 - })?; 2624 2624 + ) -> std::result::Result< 2625 2625 + tonic::Response<super::GetFilePositionResponse>, 2626 2626 + tonic::Status, 2627 2627 + > { 2628 2628 + self.inner 2629 2629 + .ready() 2630 2630 + .await 2631 2631 + .map_err(|e| { 2632 2632 + tonic::Status::unknown( 2633 2633 + format!("Service was not ready: {}", e.into()), 2634 2634 + ) 2635 2635 + })?; 2308 2636 let codec = tonic::codec::ProstCodec::default(); 2309 2637 let path = http::uri::PathAndQuery::from_static( 2310 2638 "/rockbox.v1alpha1.PlaybackService/GetFilePosition", 2311 2639 ); 2312 2640 let mut req = request.into_request(); 2313 2313 - req.extensions_mut().insert(GrpcMethod::new( 2314 2314 - "rockbox.v1alpha1.PlaybackService", 2315 2315 - "GetFilePosition", 2316 2316 - )); 2641 2641 + req.extensions_mut() 2642 2642 + .insert( 2643 2643 + GrpcMethod::new( 2644 2644 + "rockbox.v1alpha1.PlaybackService", 2645 2645 + "GetFilePosition", 2646 2646 + ), 2647 2647 + ); 2317 2648 self.inner.unary(req, path, codec).await 2318 2649 } 2319 2650 pub async fn hard_stop( 2320 2651 &mut self, 2321 2652 request: impl tonic::IntoRequest<super::HardStopRequest>, 2322 2322 - ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status> { 2323 2323 - self.inner.ready().await.map_err(|e| { 2324 2324 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2325 2325 - })?; 2653 2653 + ) -> std::result::Result< 2654 2654 + tonic::Response<super::HardStopResponse>, 2655 2655 + tonic::Status, 2656 2656 + > { 2657 2657 + self.inner 2658 2658 + .ready() 2659 2659 + .await 2660 2660 + .map_err(|e| { 2661 2661 + tonic::Status::unknown( 2662 2662 + format!("Service was not ready: {}", e.into()), 2663 2663 + ) 2664 2664 + })?; 2326 2665 let codec = tonic::codec::ProstCodec::default(); 2327 2327 - let path = 2328 2328 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/HardStop"); 2666 2666 + let path = http::uri::PathAndQuery::from_static( 2667 2667 + "/rockbox.v1alpha1.PlaybackService/HardStop", 2668 2668 + ); 2329 2669 let mut req = request.into_request(); 2330 2330 - req.extensions_mut().insert(GrpcMethod::new( 2331 2331 - "rockbox.v1alpha1.PlaybackService", 2332 2332 - "HardStop", 2333 2333 - )); 2670 2670 + req.extensions_mut() 2671 2671 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "HardStop")); 2334 2672 self.inner.unary(req, path, codec).await 2335 2673 } 2336 2674 pub async fn play_album( 2337 2675 &mut self, 2338 2676 request: impl tonic::IntoRequest<super::PlayAlbumRequest>, 2339 2339 - ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status> { 2340 2340 - self.inner.ready().await.map_err(|e| { 2341 2341 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2342 2342 - })?; 2677 2677 + ) -> std::result::Result< 2678 2678 + tonic::Response<super::PlayAlbumResponse>, 2679 2679 + tonic::Status, 2680 2680 + > { 2681 2681 + self.inner 2682 2682 + .ready() 2683 2683 + .await 2684 2684 + .map_err(|e| { 2685 2685 + tonic::Status::unknown( 2686 2686 + format!("Service was not ready: {}", e.into()), 2687 2687 + ) 2688 2688 + })?; 2343 2689 let codec = tonic::codec::ProstCodec::default(); 2344 2344 - let path = 2345 2345 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayAlbum"); 2690 2690 + let path = http::uri::PathAndQuery::from_static( 2691 2691 + "/rockbox.v1alpha1.PlaybackService/PlayAlbum", 2692 2692 + ); 2346 2693 let mut req = request.into_request(); 2347 2347 - req.extensions_mut().insert(GrpcMethod::new( 2348 2348 - "rockbox.v1alpha1.PlaybackService", 2349 2349 - "PlayAlbum", 2350 2350 - )); 2694 2694 + req.extensions_mut() 2695 2695 + .insert( 2696 2696 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAlbum"), 2697 2697 + ); 2351 2698 self.inner.unary(req, path, codec).await 2352 2699 } 2353 2700 pub async fn play_artist_tracks( 2354 2701 &mut self, 2355 2702 request: impl tonic::IntoRequest<super::PlayArtistTracksRequest>, 2356 2356 - ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status> 2357 2357 - { 2358 2358 - self.inner.ready().await.map_err(|e| { 2359 2359 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2360 2360 - })?; 2703 2703 + ) -> std::result::Result< 2704 2704 + tonic::Response<super::PlayArtistTracksResponse>, 2705 2705 + tonic::Status, 2706 2706 + > { 2707 2707 + self.inner 2708 2708 + .ready() 2709 2709 + .await 2710 2710 + .map_err(|e| { 2711 2711 + tonic::Status::unknown( 2712 2712 + format!("Service was not ready: {}", e.into()), 2713 2713 + ) 2714 2714 + })?; 2361 2715 let codec = tonic::codec::ProstCodec::default(); 2362 2716 let path = http::uri::PathAndQuery::from_static( 2363 2717 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks", 2364 2718 ); 2365 2719 let mut req = request.into_request(); 2366 2366 - req.extensions_mut().insert(GrpcMethod::new( 2367 2367 - "rockbox.v1alpha1.PlaybackService", 2368 2368 - "PlayArtistTracks", 2369 2369 - )); 2720 2720 + req.extensions_mut() 2721 2721 + .insert( 2722 2722 + GrpcMethod::new( 2723 2723 + "rockbox.v1alpha1.PlaybackService", 2724 2724 + "PlayArtistTracks", 2725 2725 + ), 2726 2726 + ); 2370 2727 self.inner.unary(req, path, codec).await 2371 2728 } 2372 2729 pub async fn play_playlist( 2373 2730 &mut self, 2374 2731 request: impl tonic::IntoRequest<super::PlayPlaylistRequest>, 2375 2375 - ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status> 2376 2376 - { 2377 2377 - self.inner.ready().await.map_err(|e| { 2378 2378 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2379 2379 - })?; 2732 2732 + ) -> std::result::Result< 2733 2733 + tonic::Response<super::PlayPlaylistResponse>, 2734 2734 + tonic::Status, 2735 2735 + > { 2736 2736 + self.inner 2737 2737 + .ready() 2738 2738 + .await 2739 2739 + .map_err(|e| { 2740 2740 + tonic::Status::unknown( 2741 2741 + format!("Service was not ready: {}", e.into()), 2742 2742 + ) 2743 2743 + })?; 2380 2744 let codec = tonic::codec::ProstCodec::default(); 2381 2745 let path = http::uri::PathAndQuery::from_static( 2382 2746 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist", 2383 2747 ); 2384 2748 let mut req = request.into_request(); 2385 2385 - req.extensions_mut().insert(GrpcMethod::new( 2386 2386 - "rockbox.v1alpha1.PlaybackService", 2387 2387 - "PlayPlaylist", 2388 2388 - )); 2749 2749 + req.extensions_mut() 2750 2750 + .insert( 2751 2751 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayPlaylist"), 2752 2752 + ); 2389 2753 self.inner.unary(req, path, codec).await 2390 2754 } 2391 2755 pub async fn play_directory( 2392 2756 &mut self, 2393 2757 request: impl tonic::IntoRequest<super::PlayDirectoryRequest>, 2394 2394 - ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status> 2395 2395 - { 2396 2396 - self.inner.ready().await.map_err(|e| { 2397 2397 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2398 2398 - })?; 2758 2758 + ) -> std::result::Result< 2759 2759 + tonic::Response<super::PlayDirectoryResponse>, 2760 2760 + tonic::Status, 2761 2761 + > { 2762 2762 + self.inner 2763 2763 + .ready() 2764 2764 + .await 2765 2765 + .map_err(|e| { 2766 2766 + tonic::Status::unknown( 2767 2767 + format!("Service was not ready: {}", e.into()), 2768 2768 + ) 2769 2769 + })?; 2399 2770 let codec = tonic::codec::ProstCodec::default(); 2400 2771 let path = http::uri::PathAndQuery::from_static( 2401 2772 "/rockbox.v1alpha1.PlaybackService/PlayDirectory", 2402 2773 ); 2403 2774 let mut req = request.into_request(); 2404 2404 - req.extensions_mut().insert(GrpcMethod::new( 2405 2405 - "rockbox.v1alpha1.PlaybackService", 2406 2406 - "PlayDirectory", 2407 2407 - )); 2775 2775 + req.extensions_mut() 2776 2776 + .insert( 2777 2777 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayDirectory"), 2778 2778 + ); 2408 2779 self.inner.unary(req, path, codec).await 2409 2780 } 2410 2781 pub async fn play_track( 2411 2782 &mut self, 2412 2783 request: impl tonic::IntoRequest<super::PlayTrackRequest>, 2413 2413 - ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status> { 2414 2414 - self.inner.ready().await.map_err(|e| { 2415 2415 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2416 2416 - })?; 2784 2784 + ) -> std::result::Result< 2785 2785 + tonic::Response<super::PlayTrackResponse>, 2786 2786 + tonic::Status, 2787 2787 + > { 2788 2788 + self.inner 2789 2789 + .ready() 2790 2790 + .await 2791 2791 + .map_err(|e| { 2792 2792 + tonic::Status::unknown( 2793 2793 + format!("Service was not ready: {}", e.into()), 2794 2794 + ) 2795 2795 + })?; 2417 2796 let codec = tonic::codec::ProstCodec::default(); 2418 2418 - let path = 2419 2419 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaybackService/PlayTrack"); 2797 2797 + let path = http::uri::PathAndQuery::from_static( 2798 2798 + "/rockbox.v1alpha1.PlaybackService/PlayTrack", 2799 2799 + ); 2420 2800 let mut req = request.into_request(); 2421 2421 - req.extensions_mut().insert(GrpcMethod::new( 2422 2422 - "rockbox.v1alpha1.PlaybackService", 2423 2423 - "PlayTrack", 2424 2424 - )); 2801 2801 + req.extensions_mut() 2802 2802 + .insert( 2803 2803 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayTrack"), 2804 2804 + ); 2425 2805 self.inner.unary(req, path, codec).await 2426 2806 } 2427 2807 pub async fn play_liked_tracks( 2428 2808 &mut self, 2429 2809 request: impl tonic::IntoRequest<super::PlayLikedTracksRequest>, 2430 2430 - ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status> 2431 2431 - { 2432 2432 - self.inner.ready().await.map_err(|e| { 2433 2433 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2434 2434 - })?; 2810 2810 + ) -> std::result::Result< 2811 2811 + tonic::Response<super::PlayLikedTracksResponse>, 2812 2812 + tonic::Status, 2813 2813 + > { 2814 2814 + self.inner 2815 2815 + .ready() 2816 2816 + .await 2817 2817 + .map_err(|e| { 2818 2818 + tonic::Status::unknown( 2819 2819 + format!("Service was not ready: {}", e.into()), 2820 2820 + ) 2821 2821 + })?; 2435 2822 let codec = tonic::codec::ProstCodec::default(); 2436 2823 let path = http::uri::PathAndQuery::from_static( 2437 2824 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks", 2438 2825 ); 2439 2826 let mut req = request.into_request(); 2440 2440 - req.extensions_mut().insert(GrpcMethod::new( 2441 2441 - "rockbox.v1alpha1.PlaybackService", 2442 2442 - "PlayLikedTracks", 2443 2443 - )); 2827 2827 + req.extensions_mut() 2828 2828 + .insert( 2829 2829 + GrpcMethod::new( 2830 2830 + "rockbox.v1alpha1.PlaybackService", 2831 2831 + "PlayLikedTracks", 2832 2832 + ), 2833 2833 + ); 2444 2834 self.inner.unary(req, path, codec).await 2445 2835 } 2446 2836 pub async fn play_all_tracks( 2447 2837 &mut self, 2448 2838 request: impl tonic::IntoRequest<super::PlayAllTracksRequest>, 2449 2449 - ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status> 2450 2450 - { 2451 2451 - self.inner.ready().await.map_err(|e| { 2452 2452 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2453 2453 - })?; 2839 2839 + ) -> std::result::Result< 2840 2840 + tonic::Response<super::PlayAllTracksResponse>, 2841 2841 + tonic::Status, 2842 2842 + > { 2843 2843 + self.inner 2844 2844 + .ready() 2845 2845 + .await 2846 2846 + .map_err(|e| { 2847 2847 + tonic::Status::unknown( 2848 2848 + format!("Service was not ready: {}", e.into()), 2849 2849 + ) 2850 2850 + })?; 2454 2851 let codec = tonic::codec::ProstCodec::default(); 2455 2852 let path = http::uri::PathAndQuery::from_static( 2456 2853 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks", 2457 2854 ); 2458 2855 let mut req = request.into_request(); 2459 2459 - req.extensions_mut().insert(GrpcMethod::new( 2460 2460 - "rockbox.v1alpha1.PlaybackService", 2461 2461 - "PlayAllTracks", 2462 2462 - )); 2856 2856 + req.extensions_mut() 2857 2857 + .insert( 2858 2858 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "PlayAllTracks"), 2859 2859 + ); 2463 2860 self.inner.unary(req, path, codec).await 2464 2861 } 2465 2862 pub async fn stream_current_track( ··· 2469 2866 tonic::Response<tonic::codec::Streaming<super::CurrentTrackResponse>>, 2470 2867 tonic::Status, 2471 2868 > { 2472 2472 - self.inner.ready().await.map_err(|e| { 2473 2473 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2474 2474 - })?; 2869 2869 + self.inner 2870 2870 + .ready() 2871 2871 + .await 2872 2872 + .map_err(|e| { 2873 2873 + tonic::Status::unknown( 2874 2874 + format!("Service was not ready: {}", e.into()), 2875 2875 + ) 2876 2876 + })?; 2475 2877 let codec = tonic::codec::ProstCodec::default(); 2476 2878 let path = http::uri::PathAndQuery::from_static( 2477 2879 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack", 2478 2880 ); 2479 2881 let mut req = request.into_request(); 2480 2480 - req.extensions_mut().insert(GrpcMethod::new( 2481 2481 - "rockbox.v1alpha1.PlaybackService", 2482 2482 - "StreamCurrentTrack", 2483 2483 - )); 2882 2882 + req.extensions_mut() 2883 2883 + .insert( 2884 2884 + GrpcMethod::new( 2885 2885 + "rockbox.v1alpha1.PlaybackService", 2886 2886 + "StreamCurrentTrack", 2887 2887 + ), 2888 2888 + ); 2484 2889 self.inner.server_streaming(req, path, codec).await 2485 2890 } 2486 2891 pub async fn stream_status( ··· 2490 2895 tonic::Response<tonic::codec::Streaming<super::StatusResponse>>, 2491 2896 tonic::Status, 2492 2897 > { 2493 2493 - self.inner.ready().await.map_err(|e| { 2494 2494 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2495 2495 - })?; 2898 2898 + self.inner 2899 2899 + .ready() 2900 2900 + .await 2901 2901 + .map_err(|e| { 2902 2902 + tonic::Status::unknown( 2903 2903 + format!("Service was not ready: {}", e.into()), 2904 2904 + ) 2905 2905 + })?; 2496 2906 let codec = tonic::codec::ProstCodec::default(); 2497 2907 let path = http::uri::PathAndQuery::from_static( 2498 2908 "/rockbox.v1alpha1.PlaybackService/StreamStatus", 2499 2909 ); 2500 2910 let mut req = request.into_request(); 2501 2501 - req.extensions_mut().insert(GrpcMethod::new( 2502 2502 - "rockbox.v1alpha1.PlaybackService", 2503 2503 - "StreamStatus", 2504 2504 - )); 2911 2911 + req.extensions_mut() 2912 2912 + .insert( 2913 2913 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamStatus"), 2914 2914 + ); 2505 2915 self.inner.server_streaming(req, path, codec).await 2506 2916 } 2507 2917 pub async fn stream_playlist( ··· 2511 2921 tonic::Response<tonic::codec::Streaming<super::PlaylistResponse>>, 2512 2922 tonic::Status, 2513 2923 > { 2514 2514 - self.inner.ready().await.map_err(|e| { 2515 2515 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 2516 2516 - })?; 2924 2924 + self.inner 2925 2925 + .ready() 2926 2926 + .await 2927 2927 + .map_err(|e| { 2928 2928 + tonic::Status::unknown( 2929 2929 + format!("Service was not ready: {}", e.into()), 2930 2930 + ) 2931 2931 + })?; 2517 2932 let codec = tonic::codec::ProstCodec::default(); 2518 2933 let path = http::uri::PathAndQuery::from_static( 2519 2934 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist", 2520 2935 ); 2521 2936 let mut req = request.into_request(); 2522 2522 - req.extensions_mut().insert(GrpcMethod::new( 2523 2523 - "rockbox.v1alpha1.PlaybackService", 2524 2524 - "StreamPlaylist", 2525 2525 - )); 2937 2937 + req.extensions_mut() 2938 2938 + .insert( 2939 2939 + GrpcMethod::new("rockbox.v1alpha1.PlaybackService", "StreamPlaylist"), 2940 2940 + ); 2526 2941 self.inner.server_streaming(req, path, codec).await 2527 2942 } 2528 2943 } ··· 2534 2949 dead_code, 2535 2950 missing_docs, 2536 2951 clippy::wildcard_imports, 2537 2537 - clippy::let_unit_value 2952 2952 + clippy::let_unit_value, 2538 2953 )] 2539 2954 use tonic::codegen::*; 2540 2955 /// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer. ··· 2559 2974 async fn previous( 2560 2975 &self, 2561 2976 request: tonic::Request<super::PreviousRequest>, 2562 2562 - ) -> std::result::Result<tonic::Response<super::PreviousResponse>, tonic::Status>; 2977 2977 + ) -> std::result::Result< 2978 2978 + tonic::Response<super::PreviousResponse>, 2979 2979 + tonic::Status, 2980 2980 + >; 2563 2981 async fn fast_forward_rewind( 2564 2982 &self, 2565 2983 request: tonic::Request<super::FastForwardRewindRequest>, 2566 2566 - ) -> std::result::Result<tonic::Response<super::FastForwardRewindResponse>, tonic::Status>; 2984 2984 + ) -> std::result::Result< 2985 2985 + tonic::Response<super::FastForwardRewindResponse>, 2986 2986 + tonic::Status, 2987 2987 + >; 2567 2988 async fn status( 2568 2989 &self, 2569 2990 request: tonic::Request<super::StatusRequest>, ··· 2571 2992 async fn current_track( 2572 2993 &self, 2573 2994 request: tonic::Request<super::CurrentTrackRequest>, 2574 2574 - ) -> std::result::Result<tonic::Response<super::CurrentTrackResponse>, tonic::Status>; 2995 2995 + ) -> std::result::Result< 2996 2996 + tonic::Response<super::CurrentTrackResponse>, 2997 2997 + tonic::Status, 2998 2998 + >; 2575 2999 async fn next_track( 2576 3000 &self, 2577 3001 request: tonic::Request<super::NextTrackRequest>, 2578 2578 - ) -> std::result::Result<tonic::Response<super::NextTrackResponse>, tonic::Status>; 3002 3002 + ) -> std::result::Result< 3003 3003 + tonic::Response<super::NextTrackResponse>, 3004 3004 + tonic::Status, 3005 3005 + >; 2579 3006 async fn flush_and_reload_tracks( 2580 3007 &self, 2581 3008 request: tonic::Request<super::FlushAndReloadTracksRequest>, 2582 2582 - ) -> std::result::Result<tonic::Response<super::FlushAndReloadTracksResponse>, tonic::Status>; 3009 3009 + ) -> std::result::Result< 3010 3010 + tonic::Response<super::FlushAndReloadTracksResponse>, 3011 3011 + tonic::Status, 3012 3012 + >; 2583 3013 async fn get_file_position( 2584 3014 &self, 2585 3015 request: tonic::Request<super::GetFilePositionRequest>, 2586 2586 - ) -> std::result::Result<tonic::Response<super::GetFilePositionResponse>, tonic::Status>; 3016 3016 + ) -> std::result::Result< 3017 3017 + tonic::Response<super::GetFilePositionResponse>, 3018 3018 + tonic::Status, 3019 3019 + >; 2587 3020 async fn hard_stop( 2588 3021 &self, 2589 3022 request: tonic::Request<super::HardStopRequest>, 2590 2590 - ) -> std::result::Result<tonic::Response<super::HardStopResponse>, tonic::Status>; 3023 3023 + ) -> std::result::Result< 3024 3024 + tonic::Response<super::HardStopResponse>, 3025 3025 + tonic::Status, 3026 3026 + >; 2591 3027 async fn play_album( 2592 3028 &self, 2593 3029 request: tonic::Request<super::PlayAlbumRequest>, 2594 2594 - ) -> std::result::Result<tonic::Response<super::PlayAlbumResponse>, tonic::Status>; 3030 3030 + ) -> std::result::Result< 3031 3031 + tonic::Response<super::PlayAlbumResponse>, 3032 3032 + tonic::Status, 3033 3033 + >; 2595 3034 async fn play_artist_tracks( 2596 3035 &self, 2597 3036 request: tonic::Request<super::PlayArtistTracksRequest>, 2598 2598 - ) -> std::result::Result<tonic::Response<super::PlayArtistTracksResponse>, tonic::Status>; 3037 3037 + ) -> std::result::Result< 3038 3038 + tonic::Response<super::PlayArtistTracksResponse>, 3039 3039 + tonic::Status, 3040 3040 + >; 2599 3041 async fn play_playlist( 2600 3042 &self, 2601 3043 request: tonic::Request<super::PlayPlaylistRequest>, 2602 2602 - ) -> std::result::Result<tonic::Response<super::PlayPlaylistResponse>, tonic::Status>; 3044 3044 + ) -> std::result::Result< 3045 3045 + tonic::Response<super::PlayPlaylistResponse>, 3046 3046 + tonic::Status, 3047 3047 + >; 2603 3048 async fn play_directory( 2604 3049 &self, 2605 3050 request: tonic::Request<super::PlayDirectoryRequest>, 2606 2606 - ) -> std::result::Result<tonic::Response<super::PlayDirectoryResponse>, tonic::Status>; 3051 3051 + ) -> std::result::Result< 3052 3052 + tonic::Response<super::PlayDirectoryResponse>, 3053 3053 + tonic::Status, 3054 3054 + >; 2607 3055 async fn play_track( 2608 3056 &self, 2609 3057 request: tonic::Request<super::PlayTrackRequest>, 2610 2610 - ) -> std::result::Result<tonic::Response<super::PlayTrackResponse>, tonic::Status>; 3058 3058 + ) -> std::result::Result< 3059 3059 + tonic::Response<super::PlayTrackResponse>, 3060 3060 + tonic::Status, 3061 3061 + >; 2611 3062 async fn play_liked_tracks( 2612 3063 &self, 2613 3064 request: tonic::Request<super::PlayLikedTracksRequest>, 2614 2614 - ) -> std::result::Result<tonic::Response<super::PlayLikedTracksResponse>, tonic::Status>; 3065 3065 + ) -> std::result::Result< 3066 3066 + tonic::Response<super::PlayLikedTracksResponse>, 3067 3067 + tonic::Status, 3068 3068 + >; 2615 3069 async fn play_all_tracks( 2616 3070 &self, 2617 3071 request: tonic::Request<super::PlayAllTracksRequest>, 2618 2618 - ) -> std::result::Result<tonic::Response<super::PlayAllTracksResponse>, tonic::Status>; 3072 3072 + ) -> std::result::Result< 3073 3073 + tonic::Response<super::PlayAllTracksResponse>, 3074 3074 + tonic::Status, 3075 3075 + >; 2619 3076 /// Server streaming response type for the StreamCurrentTrack method. 2620 3077 type StreamCurrentTrackStream: tonic::codegen::tokio_stream::Stream< 2621 3078 Item = std::result::Result<super::CurrentTrackResponse, tonic::Status>, 2622 2622 - > + std::marker::Send 3079 3079 + > 3080 3080 + + std::marker::Send 2623 3081 + 'static; 2624 3082 async fn stream_current_track( 2625 3083 &self, 2626 3084 request: tonic::Request<super::StreamCurrentTrackRequest>, 2627 2627 - ) -> std::result::Result<tonic::Response<Self::StreamCurrentTrackStream>, tonic::Status>; 3085 3085 + ) -> std::result::Result< 3086 3086 + tonic::Response<Self::StreamCurrentTrackStream>, 3087 3087 + tonic::Status, 3088 3088 + >; 2628 3089 /// Server streaming response type for the StreamStatus method. 2629 3090 type StreamStatusStream: tonic::codegen::tokio_stream::Stream< 2630 3091 Item = std::result::Result<super::StatusResponse, tonic::Status>, 2631 2631 - > + std::marker::Send 3092 3092 + > 3093 3093 + + std::marker::Send 2632 3094 + 'static; 2633 3095 async fn stream_status( 2634 3096 &self, 2635 3097 request: tonic::Request<super::StreamStatusRequest>, 2636 2636 - ) -> std::result::Result<tonic::Response<Self::StreamStatusStream>, tonic::Status>; 3098 3098 + ) -> std::result::Result< 3099 3099 + tonic::Response<Self::StreamStatusStream>, 3100 3100 + tonic::Status, 3101 3101 + >; 2637 3102 /// Server streaming response type for the StreamPlaylist method. 2638 3103 type StreamPlaylistStream: tonic::codegen::tokio_stream::Stream< 2639 3104 Item = std::result::Result<super::PlaylistResponse, tonic::Status>, 2640 2640 - > + std::marker::Send 3105 3105 + > 3106 3106 + + std::marker::Send 2641 3107 + 'static; 2642 3108 async fn stream_playlist( 2643 3109 &self, 2644 3110 request: tonic::Request<super::StreamPlaylistRequest>, 2645 2645 - ) -> std::result::Result<tonic::Response<Self::StreamPlaylistStream>, tonic::Status>; 3111 3111 + ) -> std::result::Result< 3112 3112 + tonic::Response<Self::StreamPlaylistStream>, 3113 3113 + tonic::Status, 3114 3114 + >; 2646 3115 } 2647 3116 #[derive(Debug)] 2648 3117 pub struct PlaybackServiceServer<T> { ··· 2665 3134 max_encoding_message_size: None, 2666 3135 } 2667 3136 } 2668 2668 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 3137 3137 + pub fn with_interceptor<F>( 3138 3138 + inner: T, 3139 3139 + interceptor: F, 3140 3140 + ) -> InterceptedService<Self, F> 2669 3141 where 2670 3142 F: tonic::service::Interceptor, 2671 3143 { ··· 2720 3192 "/rockbox.v1alpha1.PlaybackService/Play" => { 2721 3193 #[allow(non_camel_case_types)] 2722 3194 struct PlaySvc<T: PlaybackService>(pub Arc<T>); 2723 2723 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 3195 3195 + impl< 3196 3196 + T: PlaybackService, 3197 3197 + > tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 2724 3198 type Response = super::PlayResponse; 2725 2725 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3199 3199 + type Future = BoxFuture< 3200 3200 + tonic::Response<Self::Response>, 3201 3201 + tonic::Status, 3202 3202 + >; 2726 3203 fn call( 2727 3204 &mut self, 2728 3205 request: tonic::Request<super::PlayRequest>, 2729 3206 ) -> Self::Future { 2730 3207 let inner = Arc::clone(&self.0); 2731 2731 - let fut = 2732 2732 - async move { <T as PlaybackService>::play(&inner, request).await }; 3208 3208 + let fut = async move { 3209 3209 + <T as PlaybackService>::play(&inner, request).await 3210 3210 + }; 2733 3211 Box::pin(fut) 2734 3212 } 2735 3213 } ··· 2758 3236 "/rockbox.v1alpha1.PlaybackService/Pause" => { 2759 3237 #[allow(non_camel_case_types)] 2760 3238 struct PauseSvc<T: PlaybackService>(pub Arc<T>); 2761 2761 - impl<T: PlaybackService> tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 3239 3239 + impl< 3240 3240 + T: PlaybackService, 3241 3241 + > tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> { 2762 3242 type Response = super::PauseResponse; 2763 2763 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3243 3243 + type Future = BoxFuture< 3244 3244 + tonic::Response<Self::Response>, 3245 3245 + tonic::Status, 3246 3246 + >; 2764 3247 fn call( 2765 3248 &mut self, 2766 3249 request: tonic::Request<super::PauseRequest>, 2767 3250 ) -> Self::Future { 2768 3251 let inner = Arc::clone(&self.0); 2769 2769 - let fut = 2770 2770 - async move { <T as PlaybackService>::pause(&inner, request).await }; 3252 3252 + let fut = async move { 3253 3253 + <T as PlaybackService>::pause(&inner, request).await 3254 3254 + }; 2771 3255 Box::pin(fut) 2772 3256 } 2773 3257 } ··· 2796 3280 "/rockbox.v1alpha1.PlaybackService/Resume" => { 2797 3281 #[allow(non_camel_case_types)] 2798 3282 struct ResumeSvc<T: PlaybackService>(pub Arc<T>); 2799 2799 - impl<T: PlaybackService> tonic::server::UnaryService<super::ResumeRequest> for ResumeSvc<T> { 3283 3283 + impl< 3284 3284 + T: PlaybackService, 3285 3285 + > tonic::server::UnaryService<super::ResumeRequest> 3286 3286 + for ResumeSvc<T> { 2800 3287 type Response = super::ResumeResponse; 2801 2801 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3288 3288 + type Future = BoxFuture< 3289 3289 + tonic::Response<Self::Response>, 3290 3290 + tonic::Status, 3291 3291 + >; 2802 3292 fn call( 2803 3293 &mut self, 2804 3294 request: tonic::Request<super::ResumeRequest>, ··· 2835 3325 "/rockbox.v1alpha1.PlaybackService/Next" => { 2836 3326 #[allow(non_camel_case_types)] 2837 3327 struct NextSvc<T: PlaybackService>(pub Arc<T>); 2838 2838 - impl<T: PlaybackService> tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 3328 3328 + impl< 3329 3329 + T: PlaybackService, 3330 3330 + > tonic::server::UnaryService<super::NextRequest> for NextSvc<T> { 2839 3331 type Response = super::NextResponse; 2840 2840 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3332 3332 + type Future = BoxFuture< 3333 3333 + tonic::Response<Self::Response>, 3334 3334 + tonic::Status, 3335 3335 + >; 2841 3336 fn call( 2842 3337 &mut self, 2843 3338 request: tonic::Request<super::NextRequest>, 2844 3339 ) -> Self::Future { 2845 3340 let inner = Arc::clone(&self.0); 2846 2846 - let fut = 2847 2847 - async move { <T as PlaybackService>::next(&inner, request).await }; 3341 3341 + let fut = async move { 3342 3342 + <T as PlaybackService>::next(&inner, request).await 3343 3343 + }; 2848 3344 Box::pin(fut) 2849 3345 } 2850 3346 } ··· 2873 3369 "/rockbox.v1alpha1.PlaybackService/Previous" => { 2874 3370 #[allow(non_camel_case_types)] 2875 3371 struct PreviousSvc<T: PlaybackService>(pub Arc<T>); 2876 2876 - impl<T: PlaybackService> tonic::server::UnaryService<super::PreviousRequest> for PreviousSvc<T> { 3372 3372 + impl< 3373 3373 + T: PlaybackService, 3374 3374 + > tonic::server::UnaryService<super::PreviousRequest> 3375 3375 + for PreviousSvc<T> { 2877 3376 type Response = super::PreviousResponse; 2878 2878 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3377 3377 + type Future = BoxFuture< 3378 3378 + tonic::Response<Self::Response>, 3379 3379 + tonic::Status, 3380 3380 + >; 2879 3381 fn call( 2880 3382 &mut self, 2881 3383 request: tonic::Request<super::PreviousRequest>, ··· 2912 3414 "/rockbox.v1alpha1.PlaybackService/FastForwardRewind" => { 2913 3415 #[allow(non_camel_case_types)] 2914 3416 struct FastForwardRewindSvc<T: PlaybackService>(pub Arc<T>); 2915 2915 - impl<T: PlaybackService> 2916 2916 - tonic::server::UnaryService<super::FastForwardRewindRequest> 2917 2917 - for FastForwardRewindSvc<T> 2918 2918 - { 3417 3417 + impl< 3418 3418 + T: PlaybackService, 3419 3419 + > tonic::server::UnaryService<super::FastForwardRewindRequest> 3420 3420 + for FastForwardRewindSvc<T> { 2919 3421 type Response = super::FastForwardRewindResponse; 2920 2920 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3422 3422 + type Future = BoxFuture< 3423 3423 + tonic::Response<Self::Response>, 3424 3424 + tonic::Status, 3425 3425 + >; 2921 3426 fn call( 2922 3427 &mut self, 2923 3428 request: tonic::Request<super::FastForwardRewindRequest>, 2924 3429 ) -> Self::Future { 2925 3430 let inner = Arc::clone(&self.0); 2926 3431 let fut = async move { 2927 2927 - <T as PlaybackService>::fast_forward_rewind(&inner, request).await 3432 3432 + <T as PlaybackService>::fast_forward_rewind(&inner, request) 3433 3433 + .await 2928 3434 }; 2929 3435 Box::pin(fut) 2930 3436 } ··· 2954 3460 "/rockbox.v1alpha1.PlaybackService/Status" => { 2955 3461 #[allow(non_camel_case_types)] 2956 3462 struct StatusSvc<T: PlaybackService>(pub Arc<T>); 2957 2957 - impl<T: PlaybackService> tonic::server::UnaryService<super::StatusRequest> for StatusSvc<T> { 3463 3463 + impl< 3464 3464 + T: PlaybackService, 3465 3465 + > tonic::server::UnaryService<super::StatusRequest> 3466 3466 + for StatusSvc<T> { 2958 3467 type Response = super::StatusResponse; 2959 2959 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3468 3468 + type Future = BoxFuture< 3469 3469 + tonic::Response<Self::Response>, 3470 3470 + tonic::Status, 3471 3471 + >; 2960 3472 fn call( 2961 3473 &mut self, 2962 3474 request: tonic::Request<super::StatusRequest>, ··· 2993 3505 "/rockbox.v1alpha1.PlaybackService/CurrentTrack" => { 2994 3506 #[allow(non_camel_case_types)] 2995 3507 struct CurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 2996 2996 - impl<T: PlaybackService> tonic::server::UnaryService<super::CurrentTrackRequest> 2997 2997 - for CurrentTrackSvc<T> 2998 2998 - { 3508 3508 + impl< 3509 3509 + T: PlaybackService, 3510 3510 + > tonic::server::UnaryService<super::CurrentTrackRequest> 3511 3511 + for CurrentTrackSvc<T> { 2999 3512 type Response = super::CurrentTrackResponse; 3000 3000 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3513 3513 + type Future = BoxFuture< 3514 3514 + tonic::Response<Self::Response>, 3515 3515 + tonic::Status, 3516 3516 + >; 3001 3517 fn call( 3002 3518 &mut self, 3003 3519 request: tonic::Request<super::CurrentTrackRequest>, ··· 3034 3550 "/rockbox.v1alpha1.PlaybackService/NextTrack" => { 3035 3551 #[allow(non_camel_case_types)] 3036 3552 struct NextTrackSvc<T: PlaybackService>(pub Arc<T>); 3037 3037 - impl<T: PlaybackService> tonic::server::UnaryService<super::NextTrackRequest> for NextTrackSvc<T> { 3553 3553 + impl< 3554 3554 + T: PlaybackService, 3555 3555 + > tonic::server::UnaryService<super::NextTrackRequest> 3556 3556 + for NextTrackSvc<T> { 3038 3557 type Response = super::NextTrackResponse; 3039 3039 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3558 3558 + type Future = BoxFuture< 3559 3559 + tonic::Response<Self::Response>, 3560 3560 + tonic::Status, 3561 3561 + >; 3040 3562 fn call( 3041 3563 &mut self, 3042 3564 request: tonic::Request<super::NextTrackRequest>, ··· 3073 3595 "/rockbox.v1alpha1.PlaybackService/FlushAndReloadTracks" => { 3074 3596 #[allow(non_camel_case_types)] 3075 3597 struct FlushAndReloadTracksSvc<T: PlaybackService>(pub Arc<T>); 3076 3076 - impl<T: PlaybackService> 3077 3077 - tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3078 3078 - for FlushAndReloadTracksSvc<T> 3079 3079 - { 3598 3598 + impl< 3599 3599 + T: PlaybackService, 3600 3600 + > tonic::server::UnaryService<super::FlushAndReloadTracksRequest> 3601 3601 + for FlushAndReloadTracksSvc<T> { 3080 3602 type Response = super::FlushAndReloadTracksResponse; 3081 3081 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3603 3603 + type Future = BoxFuture< 3604 3604 + tonic::Response<Self::Response>, 3605 3605 + tonic::Status, 3606 3606 + >; 3082 3607 fn call( 3083 3608 &mut self, 3084 3609 request: tonic::Request<super::FlushAndReloadTracksRequest>, 3085 3610 ) -> Self::Future { 3086 3611 let inner = Arc::clone(&self.0); 3087 3612 let fut = async move { 3088 3088 - <T as PlaybackService>::flush_and_reload_tracks(&inner, request) 3613 3613 + <T as PlaybackService>::flush_and_reload_tracks( 3614 3614 + &inner, 3615 3615 + request, 3616 3616 + ) 3089 3617 .await 3090 3618 }; 3091 3619 Box::pin(fut) ··· 3116 3644 "/rockbox.v1alpha1.PlaybackService/GetFilePosition" => { 3117 3645 #[allow(non_camel_case_types)] 3118 3646 struct GetFilePositionSvc<T: PlaybackService>(pub Arc<T>); 3119 3119 - impl<T: PlaybackService> 3120 3120 - tonic::server::UnaryService<super::GetFilePositionRequest> 3121 3121 - for GetFilePositionSvc<T> 3122 3122 - { 3647 3647 + impl< 3648 3648 + T: PlaybackService, 3649 3649 + > tonic::server::UnaryService<super::GetFilePositionRequest> 3650 3650 + for GetFilePositionSvc<T> { 3123 3651 type Response = super::GetFilePositionResponse; 3124 3124 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3652 3652 + type Future = BoxFuture< 3653 3653 + tonic::Response<Self::Response>, 3654 3654 + tonic::Status, 3655 3655 + >; 3125 3656 fn call( 3126 3657 &mut self, 3127 3658 request: tonic::Request<super::GetFilePositionRequest>, 3128 3659 ) -> Self::Future { 3129 3660 let inner = Arc::clone(&self.0); 3130 3661 let fut = async move { 3131 3131 - <T as PlaybackService>::get_file_position(&inner, request).await 3662 3662 + <T as PlaybackService>::get_file_position(&inner, request) 3663 3663 + .await 3132 3664 }; 3133 3665 Box::pin(fut) 3134 3666 } ··· 3158 3690 "/rockbox.v1alpha1.PlaybackService/HardStop" => { 3159 3691 #[allow(non_camel_case_types)] 3160 3692 struct HardStopSvc<T: PlaybackService>(pub Arc<T>); 3161 3161 - impl<T: PlaybackService> tonic::server::UnaryService<super::HardStopRequest> for HardStopSvc<T> { 3693 3693 + impl< 3694 3694 + T: PlaybackService, 3695 3695 + > tonic::server::UnaryService<super::HardStopRequest> 3696 3696 + for HardStopSvc<T> { 3162 3697 type Response = super::HardStopResponse; 3163 3163 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3698 3698 + type Future = BoxFuture< 3699 3699 + tonic::Response<Self::Response>, 3700 3700 + tonic::Status, 3701 3701 + >; 3164 3702 fn call( 3165 3703 &mut self, 3166 3704 request: tonic::Request<super::HardStopRequest>, ··· 3197 3735 "/rockbox.v1alpha1.PlaybackService/PlayAlbum" => { 3198 3736 #[allow(non_camel_case_types)] 3199 3737 struct PlayAlbumSvc<T: PlaybackService>(pub Arc<T>); 3200 3200 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayAlbumRequest> for PlayAlbumSvc<T> { 3738 3738 + impl< 3739 3739 + T: PlaybackService, 3740 3740 + > tonic::server::UnaryService<super::PlayAlbumRequest> 3741 3741 + for PlayAlbumSvc<T> { 3201 3742 type Response = super::PlayAlbumResponse; 3202 3202 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3743 3743 + type Future = BoxFuture< 3744 3744 + tonic::Response<Self::Response>, 3745 3745 + tonic::Status, 3746 3746 + >; 3203 3747 fn call( 3204 3748 &mut self, 3205 3749 request: tonic::Request<super::PlayAlbumRequest>, ··· 3236 3780 "/rockbox.v1alpha1.PlaybackService/PlayArtistTracks" => { 3237 3781 #[allow(non_camel_case_types)] 3238 3782 struct PlayArtistTracksSvc<T: PlaybackService>(pub Arc<T>); 3239 3239 - impl<T: PlaybackService> 3240 3240 - tonic::server::UnaryService<super::PlayArtistTracksRequest> 3241 3241 - for PlayArtistTracksSvc<T> 3242 3242 - { 3783 3783 + impl< 3784 3784 + T: PlaybackService, 3785 3785 + > tonic::server::UnaryService<super::PlayArtistTracksRequest> 3786 3786 + for PlayArtistTracksSvc<T> { 3243 3787 type Response = super::PlayArtistTracksResponse; 3244 3244 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3788 3788 + type Future = BoxFuture< 3789 3789 + tonic::Response<Self::Response>, 3790 3790 + tonic::Status, 3791 3791 + >; 3245 3792 fn call( 3246 3793 &mut self, 3247 3794 request: tonic::Request<super::PlayArtistTracksRequest>, 3248 3795 ) -> Self::Future { 3249 3796 let inner = Arc::clone(&self.0); 3250 3797 let fut = async move { 3251 3251 - <T as PlaybackService>::play_artist_tracks(&inner, request).await 3798 3798 + <T as PlaybackService>::play_artist_tracks(&inner, request) 3799 3799 + .await 3252 3800 }; 3253 3801 Box::pin(fut) 3254 3802 } ··· 3278 3826 "/rockbox.v1alpha1.PlaybackService/PlayPlaylist" => { 3279 3827 #[allow(non_camel_case_types)] 3280 3828 struct PlayPlaylistSvc<T: PlaybackService>(pub Arc<T>); 3281 3281 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayPlaylistRequest> 3282 3282 - for PlayPlaylistSvc<T> 3283 3283 - { 3829 3829 + impl< 3830 3830 + T: PlaybackService, 3831 3831 + > tonic::server::UnaryService<super::PlayPlaylistRequest> 3832 3832 + for PlayPlaylistSvc<T> { 3284 3833 type Response = super::PlayPlaylistResponse; 3285 3285 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3834 3834 + type Future = BoxFuture< 3835 3835 + tonic::Response<Self::Response>, 3836 3836 + tonic::Status, 3837 3837 + >; 3286 3838 fn call( 3287 3839 &mut self, 3288 3840 request: tonic::Request<super::PlayPlaylistRequest>, ··· 3319 3871 "/rockbox.v1alpha1.PlaybackService/PlayDirectory" => { 3320 3872 #[allow(non_camel_case_types)] 3321 3873 struct PlayDirectorySvc<T: PlaybackService>(pub Arc<T>); 3322 3322 - impl<T: PlaybackService> 3323 3323 - tonic::server::UnaryService<super::PlayDirectoryRequest> 3324 3324 - for PlayDirectorySvc<T> 3325 3325 - { 3874 3874 + impl< 3875 3875 + T: PlaybackService, 3876 3876 + > tonic::server::UnaryService<super::PlayDirectoryRequest> 3877 3877 + for PlayDirectorySvc<T> { 3326 3878 type Response = super::PlayDirectoryResponse; 3327 3327 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3879 3879 + type Future = BoxFuture< 3880 3880 + tonic::Response<Self::Response>, 3881 3881 + tonic::Status, 3882 3882 + >; 3328 3883 fn call( 3329 3884 &mut self, 3330 3885 request: tonic::Request<super::PlayDirectoryRequest>, 3331 3886 ) -> Self::Future { 3332 3887 let inner = Arc::clone(&self.0); 3333 3888 let fut = async move { 3334 3334 - <T as PlaybackService>::play_directory(&inner, request).await 3889 3889 + <T as PlaybackService>::play_directory(&inner, request) 3890 3890 + .await 3335 3891 }; 3336 3892 Box::pin(fut) 3337 3893 } ··· 3361 3917 "/rockbox.v1alpha1.PlaybackService/PlayTrack" => { 3362 3918 #[allow(non_camel_case_types)] 3363 3919 struct PlayTrackSvc<T: PlaybackService>(pub Arc<T>); 3364 3364 - impl<T: PlaybackService> tonic::server::UnaryService<super::PlayTrackRequest> for PlayTrackSvc<T> { 3920 3920 + impl< 3921 3921 + T: PlaybackService, 3922 3922 + > tonic::server::UnaryService<super::PlayTrackRequest> 3923 3923 + for PlayTrackSvc<T> { 3365 3924 type Response = super::PlayTrackResponse; 3366 3366 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3925 3925 + type Future = BoxFuture< 3926 3926 + tonic::Response<Self::Response>, 3927 3927 + tonic::Status, 3928 3928 + >; 3367 3929 fn call( 3368 3930 &mut self, 3369 3931 request: tonic::Request<super::PlayTrackRequest>, ··· 3400 3962 "/rockbox.v1alpha1.PlaybackService/PlayLikedTracks" => { 3401 3963 #[allow(non_camel_case_types)] 3402 3964 struct PlayLikedTracksSvc<T: PlaybackService>(pub Arc<T>); 3403 3403 - impl<T: PlaybackService> 3404 3404 - tonic::server::UnaryService<super::PlayLikedTracksRequest> 3405 3405 - for PlayLikedTracksSvc<T> 3406 3406 - { 3965 3965 + impl< 3966 3966 + T: PlaybackService, 3967 3967 + > tonic::server::UnaryService<super::PlayLikedTracksRequest> 3968 3968 + for PlayLikedTracksSvc<T> { 3407 3969 type Response = super::PlayLikedTracksResponse; 3408 3408 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 3970 3970 + type Future = BoxFuture< 3971 3971 + tonic::Response<Self::Response>, 3972 3972 + tonic::Status, 3973 3973 + >; 3409 3974 fn call( 3410 3975 &mut self, 3411 3976 request: tonic::Request<super::PlayLikedTracksRequest>, 3412 3977 ) -> Self::Future { 3413 3978 let inner = Arc::clone(&self.0); 3414 3979 let fut = async move { 3415 3415 - <T as PlaybackService>::play_liked_tracks(&inner, request).await 3980 3980 + <T as PlaybackService>::play_liked_tracks(&inner, request) 3981 3981 + .await 3416 3982 }; 3417 3983 Box::pin(fut) 3418 3984 } ··· 3442 4008 "/rockbox.v1alpha1.PlaybackService/PlayAllTracks" => { 3443 4009 #[allow(non_camel_case_types)] 3444 4010 struct PlayAllTracksSvc<T: PlaybackService>(pub Arc<T>); 3445 3445 - impl<T: PlaybackService> 3446 3446 - tonic::server::UnaryService<super::PlayAllTracksRequest> 3447 3447 - for PlayAllTracksSvc<T> 3448 3448 - { 4011 4011 + impl< 4012 4012 + T: PlaybackService, 4013 4013 + > tonic::server::UnaryService<super::PlayAllTracksRequest> 4014 4014 + for PlayAllTracksSvc<T> { 3449 4015 type Response = super::PlayAllTracksResponse; 3450 3450 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 4016 4016 + type Future = BoxFuture< 4017 4017 + tonic::Response<Self::Response>, 4018 4018 + tonic::Status, 4019 4019 + >; 3451 4020 fn call( 3452 4021 &mut self, 3453 4022 request: tonic::Request<super::PlayAllTracksRequest>, 3454 4023 ) -> Self::Future { 3455 4024 let inner = Arc::clone(&self.0); 3456 4025 let fut = async move { 3457 3457 - <T as PlaybackService>::play_all_tracks(&inner, request).await 4026 4026 + <T as PlaybackService>::play_all_tracks(&inner, request) 4027 4027 + .await 3458 4028 }; 3459 4029 Box::pin(fut) 3460 4030 } ··· 3484 4054 "/rockbox.v1alpha1.PlaybackService/StreamCurrentTrack" => { 3485 4055 #[allow(non_camel_case_types)] 3486 4056 struct StreamCurrentTrackSvc<T: PlaybackService>(pub Arc<T>); 3487 3487 - impl<T: PlaybackService> 3488 3488 - tonic::server::ServerStreamingService<super::StreamCurrentTrackRequest> 3489 3489 - for StreamCurrentTrackSvc<T> 3490 3490 - { 4057 4057 + impl< 4058 4058 + T: PlaybackService, 4059 4059 + > tonic::server::ServerStreamingService< 4060 4060 + super::StreamCurrentTrackRequest, 4061 4061 + > for StreamCurrentTrackSvc<T> { 3491 4062 type Response = super::CurrentTrackResponse; 3492 4063 type ResponseStream = T::StreamCurrentTrackStream; 3493 3493 - type Future = 3494 3494 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4064 4064 + type Future = BoxFuture< 4065 4065 + tonic::Response<Self::ResponseStream>, 4066 4066 + tonic::Status, 4067 4067 + >; 3495 4068 fn call( 3496 4069 &mut self, 3497 4070 request: tonic::Request<super::StreamCurrentTrackRequest>, 3498 4071 ) -> Self::Future { 3499 4072 let inner = Arc::clone(&self.0); 3500 4073 let fut = async move { 3501 3501 - <T as PlaybackService>::stream_current_track(&inner, request).await 4074 4074 + <T as PlaybackService>::stream_current_track( 4075 4075 + &inner, 4076 4076 + request, 4077 4077 + ) 4078 4078 + .await 3502 4079 }; 3503 4080 Box::pin(fut) 3504 4081 } ··· 3528 4105 "/rockbox.v1alpha1.PlaybackService/StreamStatus" => { 3529 4106 #[allow(non_camel_case_types)] 3530 4107 struct StreamStatusSvc<T: PlaybackService>(pub Arc<T>); 3531 3531 - impl<T: PlaybackService> 3532 3532 - tonic::server::ServerStreamingService<super::StreamStatusRequest> 3533 3533 - for StreamStatusSvc<T> 3534 3534 - { 4108 4108 + impl< 4109 4109 + T: PlaybackService, 4110 4110 + > tonic::server::ServerStreamingService<super::StreamStatusRequest> 4111 4111 + for StreamStatusSvc<T> { 3535 4112 type Response = super::StatusResponse; 3536 4113 type ResponseStream = T::StreamStatusStream; 3537 3537 - type Future = 3538 3538 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4114 4114 + type Future = BoxFuture< 4115 4115 + tonic::Response<Self::ResponseStream>, 4116 4116 + tonic::Status, 4117 4117 + >; 3539 4118 fn call( 3540 4119 &mut self, 3541 4120 request: tonic::Request<super::StreamStatusRequest>, ··· 3572 4151 "/rockbox.v1alpha1.PlaybackService/StreamPlaylist" => { 3573 4152 #[allow(non_camel_case_types)] 3574 4153 struct StreamPlaylistSvc<T: PlaybackService>(pub Arc<T>); 3575 3575 - impl<T: PlaybackService> 3576 3576 - tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 3577 3577 - for StreamPlaylistSvc<T> 3578 3578 - { 4154 4154 + impl< 4155 4155 + T: PlaybackService, 4156 4156 + > tonic::server::ServerStreamingService<super::StreamPlaylistRequest> 4157 4157 + for StreamPlaylistSvc<T> { 3579 4158 type Response = super::PlaylistResponse; 3580 4159 type ResponseStream = T::StreamPlaylistStream; 3581 3581 - type Future = 3582 3582 - BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>; 4160 4160 + type Future = BoxFuture< 4161 4161 + tonic::Response<Self::ResponseStream>, 4162 4162 + tonic::Status, 4163 4163 + >; 3583 4164 fn call( 3584 4165 &mut self, 3585 4166 request: tonic::Request<super::StreamPlaylistRequest>, 3586 4167 ) -> Self::Future { 3587 4168 let inner = Arc::clone(&self.0); 3588 4169 let fut = async move { 3589 3589 - <T as PlaybackService>::stream_playlist(&inner, request).await 4170 4170 + <T as PlaybackService>::stream_playlist(&inner, request) 4171 4171 + .await 3590 4172 }; 3591 4173 Box::pin(fut) 3592 4174 } ··· 3613 4195 }; 3614 4196 Box::pin(fut) 3615 4197 } 3616 3616 - _ => Box::pin(async move { 3617 3617 - let mut response = http::Response::new(empty_body()); 3618 3618 - let headers = response.headers_mut(); 3619 3619 - headers.insert( 3620 3620 - tonic::Status::GRPC_STATUS, 3621 3621 - (tonic::Code::Unimplemented as i32).into(), 3622 3622 - ); 3623 3623 - headers.insert( 3624 3624 - http::header::CONTENT_TYPE, 3625 3625 - tonic::metadata::GRPC_CONTENT_TYPE, 3626 3626 - ); 3627 3627 - Ok(response) 3628 3628 - }), 4198 4198 + _ => { 4199 4199 + Box::pin(async move { 4200 4200 + let mut response = http::Response::new(empty_body()); 4201 4201 + let headers = response.headers_mut(); 4202 4202 + headers 4203 4203 + .insert( 4204 4204 + tonic::Status::GRPC_STATUS, 4205 4205 + (tonic::Code::Unimplemented as i32).into(), 4206 4206 + ); 4207 4207 + headers 4208 4208 + .insert( 4209 4209 + http::header::CONTENT_TYPE, 4210 4210 + tonic::metadata::GRPC_CONTENT_TYPE, 4211 4211 + ); 4212 4212 + Ok(response) 4213 4213 + }) 4214 4214 + } 3629 4215 } 3630 4216 } 3631 4217 } ··· 3830 4416 dead_code, 3831 4417 missing_docs, 3832 4418 clippy::wildcard_imports, 3833 3833 - clippy::let_unit_value 4419 4419 + clippy::let_unit_value, 3834 4420 )] 3835 3835 - use tonic::codegen::http::Uri; 3836 4421 use tonic::codegen::*; 4422 4422 + use tonic::codegen::http::Uri; 3837 4423 #[derive(Debug, Clone)] 3838 4424 pub struct PlaylistServiceClient<T> { 3839 4425 inner: tonic::client::Grpc<T>, ··· 3877 4463 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 3878 4464 >, 3879 4465 >, 3880 3880 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 3881 3881 - Into<StdError> + std::marker::Send + std::marker::Sync, 4466 4466 + <T as tonic::codegen::Service< 4467 4467 + http::Request<tonic::body::BoxBody>, 4468 4468 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 3882 4469 { 3883 4470 PlaylistServiceClient::new(InterceptedService::new(inner, interceptor)) 3884 4471 } ··· 3916 4503 pub async fn get_current( 3917 4504 &mut self, 3918 4505 request: impl tonic::IntoRequest<super::GetCurrentRequest>, 3919 3919 - ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status> 3920 3920 - { 3921 3921 - self.inner.ready().await.map_err(|e| { 3922 3922 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3923 3923 - })?; 4506 4506 + ) -> std::result::Result< 4507 4507 + tonic::Response<super::GetCurrentResponse>, 4508 4508 + tonic::Status, 4509 4509 + > { 4510 4510 + self.inner 4511 4511 + .ready() 4512 4512 + .await 4513 4513 + .map_err(|e| { 4514 4514 + tonic::Status::unknown( 4515 4515 + format!("Service was not ready: {}", e.into()), 4516 4516 + ) 4517 4517 + })?; 3924 4518 let codec = tonic::codec::ProstCodec::default(); 3925 4519 let path = http::uri::PathAndQuery::from_static( 3926 4520 "/rockbox.v1alpha1.PlaylistService/GetCurrent", 3927 4521 ); 3928 4522 let mut req = request.into_request(); 3929 3929 - req.extensions_mut().insert(GrpcMethod::new( 3930 3930 - "rockbox.v1alpha1.PlaylistService", 3931 3931 - "GetCurrent", 3932 3932 - )); 4523 4523 + req.extensions_mut() 4524 4524 + .insert( 4525 4525 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetCurrent"), 4526 4526 + ); 3933 4527 self.inner.unary(req, path, codec).await 3934 4528 } 3935 4529 pub async fn get_resume_info( 3936 4530 &mut self, 3937 4531 request: impl tonic::IntoRequest<super::GetResumeInfoRequest>, 3938 3938 - ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status> 3939 3939 - { 3940 3940 - self.inner.ready().await.map_err(|e| { 3941 3941 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3942 3942 - })?; 4532 4532 + ) -> std::result::Result< 4533 4533 + tonic::Response<super::GetResumeInfoResponse>, 4534 4534 + tonic::Status, 4535 4535 + > { 4536 4536 + self.inner 4537 4537 + .ready() 4538 4538 + .await 4539 4539 + .map_err(|e| { 4540 4540 + tonic::Status::unknown( 4541 4541 + format!("Service was not ready: {}", e.into()), 4542 4542 + ) 4543 4543 + })?; 3943 4544 let codec = tonic::codec::ProstCodec::default(); 3944 4545 let path = http::uri::PathAndQuery::from_static( 3945 4546 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo", 3946 4547 ); 3947 4548 let mut req = request.into_request(); 3948 3948 - req.extensions_mut().insert(GrpcMethod::new( 3949 3949 - "rockbox.v1alpha1.PlaylistService", 3950 3950 - "GetResumeInfo", 3951 3951 - )); 4549 4549 + req.extensions_mut() 4550 4550 + .insert( 4551 4551 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetResumeInfo"), 4552 4552 + ); 3952 4553 self.inner.unary(req, path, codec).await 3953 4554 } 3954 4555 pub async fn get_track_info( 3955 4556 &mut self, 3956 4557 request: impl tonic::IntoRequest<super::GetTrackInfoRequest>, 3957 3957 - ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status> 3958 3958 - { 3959 3959 - self.inner.ready().await.map_err(|e| { 3960 3960 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3961 3961 - })?; 4558 4558 + ) -> std::result::Result< 4559 4559 + tonic::Response<super::GetTrackInfoResponse>, 4560 4560 + tonic::Status, 4561 4561 + > { 4562 4562 + self.inner 4563 4563 + .ready() 4564 4564 + .await 4565 4565 + .map_err(|e| { 4566 4566 + tonic::Status::unknown( 4567 4567 + format!("Service was not ready: {}", e.into()), 4568 4568 + ) 4569 4569 + })?; 3962 4570 let codec = tonic::codec::ProstCodec::default(); 3963 4571 let path = http::uri::PathAndQuery::from_static( 3964 4572 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo", 3965 4573 ); 3966 4574 let mut req = request.into_request(); 3967 3967 - req.extensions_mut().insert(GrpcMethod::new( 3968 3968 - "rockbox.v1alpha1.PlaylistService", 3969 3969 - "GetTrackInfo", 3970 3970 - )); 4575 4575 + req.extensions_mut() 4576 4576 + .insert( 4577 4577 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetTrackInfo"), 4578 4578 + ); 3971 4579 self.inner.unary(req, path, codec).await 3972 4580 } 3973 4581 pub async fn get_first_index( 3974 4582 &mut self, 3975 4583 request: impl tonic::IntoRequest<super::GetFirstIndexRequest>, 3976 3976 - ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status> 3977 3977 - { 3978 3978 - self.inner.ready().await.map_err(|e| { 3979 3979 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3980 3980 - })?; 4584 4584 + ) -> std::result::Result< 4585 4585 + tonic::Response<super::GetFirstIndexResponse>, 4586 4586 + tonic::Status, 4587 4587 + > { 4588 4588 + self.inner 4589 4589 + .ready() 4590 4590 + .await 4591 4591 + .map_err(|e| { 4592 4592 + tonic::Status::unknown( 4593 4593 + format!("Service was not ready: {}", e.into()), 4594 4594 + ) 4595 4595 + })?; 3981 4596 let codec = tonic::codec::ProstCodec::default(); 3982 4597 let path = http::uri::PathAndQuery::from_static( 3983 4598 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex", 3984 4599 ); 3985 4600 let mut req = request.into_request(); 3986 3986 - req.extensions_mut().insert(GrpcMethod::new( 3987 3987 - "rockbox.v1alpha1.PlaylistService", 3988 3988 - "GetFirstIndex", 3989 3989 - )); 4601 4601 + req.extensions_mut() 4602 4602 + .insert( 4603 4603 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "GetFirstIndex"), 4604 4604 + ); 3990 4605 self.inner.unary(req, path, codec).await 3991 4606 } 3992 4607 pub async fn get_display_index( 3993 4608 &mut self, 3994 4609 request: impl tonic::IntoRequest<super::GetDisplayIndexRequest>, 3995 3995 - ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status> 3996 3996 - { 3997 3997 - self.inner.ready().await.map_err(|e| { 3998 3998 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 3999 3999 - })?; 4610 4610 + ) -> std::result::Result< 4611 4611 + tonic::Response<super::GetDisplayIndexResponse>, 4612 4612 + tonic::Status, 4613 4613 + > { 4614 4614 + self.inner 4615 4615 + .ready() 4616 4616 + .await 4617 4617 + .map_err(|e| { 4618 4618 + tonic::Status::unknown( 4619 4619 + format!("Service was not ready: {}", e.into()), 4620 4620 + ) 4621 4621 + })?; 4000 4622 let codec = tonic::codec::ProstCodec::default(); 4001 4623 let path = http::uri::PathAndQuery::from_static( 4002 4624 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex", 4003 4625 ); 4004 4626 let mut req = request.into_request(); 4005 4005 - req.extensions_mut().insert(GrpcMethod::new( 4006 4006 - "rockbox.v1alpha1.PlaylistService", 4007 4007 - "GetDisplayIndex", 4008 4008 - )); 4627 4627 + req.extensions_mut() 4628 4628 + .insert( 4629 4629 + GrpcMethod::new( 4630 4630 + "rockbox.v1alpha1.PlaylistService", 4631 4631 + "GetDisplayIndex", 4632 4632 + ), 4633 4633 + ); 4009 4634 self.inner.unary(req, path, codec).await 4010 4635 } 4011 4636 pub async fn amount( 4012 4637 &mut self, 4013 4638 request: impl tonic::IntoRequest<super::AmountRequest>, 4014 4639 ) -> std::result::Result<tonic::Response<super::AmountResponse>, tonic::Status> { 4015 4015 - self.inner.ready().await.map_err(|e| { 4016 4016 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4017 4017 - })?; 4640 4640 + self.inner 4641 4641 + .ready() 4642 4642 + .await 4643 4643 + .map_err(|e| { 4644 4644 + tonic::Status::unknown( 4645 4645 + format!("Service was not ready: {}", e.into()), 4646 4646 + ) 4647 4647 + })?; 4018 4648 let codec = tonic::codec::ProstCodec::default(); 4019 4019 - let path = 4020 4020 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Amount"); 4649 4649 + let path = http::uri::PathAndQuery::from_static( 4650 4650 + "/rockbox.v1alpha1.PlaylistService/Amount", 4651 4651 + ); 4021 4652 let mut req = request.into_request(); 4022 4022 - req.extensions_mut().insert(GrpcMethod::new( 4023 4023 - "rockbox.v1alpha1.PlaylistService", 4024 4024 - "Amount", 4025 4025 - )); 4653 4653 + req.extensions_mut() 4654 4654 + .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Amount")); 4026 4655 self.inner.unary(req, path, codec).await 4027 4656 } 4028 4657 pub async fn playlist_resume( 4029 4658 &mut self, 4030 4659 request: impl tonic::IntoRequest<super::PlaylistResumeRequest>, 4031 4031 - ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status> 4032 4032 - { 4033 4033 - self.inner.ready().await.map_err(|e| { 4034 4034 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4035 4035 - })?; 4660 4660 + ) -> std::result::Result< 4661 4661 + tonic::Response<super::PlaylistResumeResponse>, 4662 4662 + tonic::Status, 4663 4663 + > { 4664 4664 + self.inner 4665 4665 + .ready() 4666 4666 + .await 4667 4667 + .map_err(|e| { 4668 4668 + tonic::Status::unknown( 4669 4669 + format!("Service was not ready: {}", e.into()), 4670 4670 + ) 4671 4671 + })?; 4036 4672 let codec = tonic::codec::ProstCodec::default(); 4037 4673 let path = http::uri::PathAndQuery::from_static( 4038 4674 "/rockbox.v1alpha1.PlaylistService/PlaylistResume", 4039 4675 ); 4040 4676 let mut req = request.into_request(); 4041 4041 - req.extensions_mut().insert(GrpcMethod::new( 4042 4042 - "rockbox.v1alpha1.PlaylistService", 4043 4043 - "PlaylistResume", 4044 4044 - )); 4677 4677 + req.extensions_mut() 4678 4678 + .insert( 4679 4679 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "PlaylistResume"), 4680 4680 + ); 4045 4681 self.inner.unary(req, path, codec).await 4046 4682 } 4047 4683 pub async fn resume_track( 4048 4684 &mut self, 4049 4685 request: impl tonic::IntoRequest<super::ResumeTrackRequest>, 4050 4050 - ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status> 4051 4051 - { 4052 4052 - self.inner.ready().await.map_err(|e| { 4053 4053 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4054 4054 - })?; 4686 4686 + ) -> std::result::Result< 4687 4687 + tonic::Response<super::ResumeTrackResponse>, 4688 4688 + tonic::Status, 4689 4689 + > { 4690 4690 + self.inner 4691 4691 + .ready() 4692 4692 + .await 4693 4693 + .map_err(|e| { 4694 4694 + tonic::Status::unknown( 4695 4695 + format!("Service was not ready: {}", e.into()), 4696 4696 + ) 4697 4697 + })?; 4055 4698 let codec = tonic::codec::ProstCodec::default(); 4056 4699 let path = http::uri::PathAndQuery::from_static( 4057 4700 "/rockbox.v1alpha1.PlaylistService/ResumeTrack", 4058 4701 ); 4059 4702 let mut req = request.into_request(); 4060 4060 - req.extensions_mut().insert(GrpcMethod::new( 4061 4061 - "rockbox.v1alpha1.PlaylistService", 4062 4062 - "ResumeTrack", 4063 4063 - )); 4703 4703 + req.extensions_mut() 4704 4704 + .insert( 4705 4705 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "ResumeTrack"), 4706 4706 + ); 4064 4707 self.inner.unary(req, path, codec).await 4065 4708 } 4066 4709 pub async fn set_modified( 4067 4710 &mut self, 4068 4711 request: impl tonic::IntoRequest<super::SetModifiedRequest>, 4069 4069 - ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status> 4070 4070 - { 4071 4071 - self.inner.ready().await.map_err(|e| { 4072 4072 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4073 4073 - })?; 4712 4712 + ) -> std::result::Result< 4713 4713 + tonic::Response<super::SetModifiedResponse>, 4714 4714 + tonic::Status, 4715 4715 + > { 4716 4716 + self.inner 4717 4717 + .ready() 4718 4718 + .await 4719 4719 + .map_err(|e| { 4720 4720 + tonic::Status::unknown( 4721 4721 + format!("Service was not ready: {}", e.into()), 4722 4722 + ) 4723 4723 + })?; 4074 4724 let codec = tonic::codec::ProstCodec::default(); 4075 4725 let path = http::uri::PathAndQuery::from_static( 4076 4726 "/rockbox.v1alpha1.PlaylistService/SetModified", 4077 4727 ); 4078 4728 let mut req = request.into_request(); 4079 4079 - req.extensions_mut().insert(GrpcMethod::new( 4080 4080 - "rockbox.v1alpha1.PlaylistService", 4081 4081 - "SetModified", 4082 4082 - )); 4729 4729 + req.extensions_mut() 4730 4730 + .insert( 4731 4731 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "SetModified"), 4732 4732 + ); 4083 4733 self.inner.unary(req, path, codec).await 4084 4734 } 4085 4735 pub async fn start( 4086 4736 &mut self, 4087 4737 request: impl tonic::IntoRequest<super::StartRequest>, 4088 4738 ) -> std::result::Result<tonic::Response<super::StartResponse>, tonic::Status> { 4089 4089 - self.inner.ready().await.map_err(|e| { 4090 4090 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4091 4091 - })?; 4739 4739 + self.inner 4740 4740 + .ready() 4741 4741 + .await 4742 4742 + .map_err(|e| { 4743 4743 + tonic::Status::unknown( 4744 4744 + format!("Service was not ready: {}", e.into()), 4745 4745 + ) 4746 4746 + })?; 4092 4747 let codec = tonic::codec::ProstCodec::default(); 4093 4093 - let path = 4094 4094 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Start"); 4748 4748 + let path = http::uri::PathAndQuery::from_static( 4749 4749 + "/rockbox.v1alpha1.PlaylistService/Start", 4750 4750 + ); 4095 4751 let mut req = request.into_request(); 4096 4752 req.extensions_mut() 4097 4753 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Start")); ··· 4101 4757 &mut self, 4102 4758 request: impl tonic::IntoRequest<super::SyncRequest>, 4103 4759 ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> { 4104 4104 - self.inner.ready().await.map_err(|e| { 4105 4105 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4106 4106 - })?; 4760 4760 + self.inner 4761 4761 + .ready() 4762 4762 + .await 4763 4763 + .map_err(|e| { 4764 4764 + tonic::Status::unknown( 4765 4765 + format!("Service was not ready: {}", e.into()), 4766 4766 + ) 4767 4767 + })?; 4107 4768 let codec = tonic::codec::ProstCodec::default(); 4108 4108 - let path = 4109 4109 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.PlaylistService/Sync"); 4769 4769 + let path = http::uri::PathAndQuery::from_static( 4770 4770 + "/rockbox.v1alpha1.PlaylistService/Sync", 4771 4771 + ); 4110 4772 let mut req = request.into_request(); 4111 4773 req.extensions_mut() 4112 4774 .insert(GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "Sync")); ··· 4115 4777 pub async fn remove_all_tracks( 4116 4778 &mut self, 4117 4779 request: impl tonic::IntoRequest<super::RemoveAllTracksRequest>, 4118 4118 - ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status> 4119 4119 - { 4120 4120 - self.inner.ready().await.map_err(|e| { 4121 4121 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4122 4122 - })?; 4780 4780 + ) -> std::result::Result< 4781 4781 + tonic::Response<super::RemoveAllTracksResponse>, 4782 4782 + tonic::Status, 4783 4783 + > { 4784 4784 + self.inner 4785 4785 + .ready() 4786 4786 + .await 4787 4787 + .map_err(|e| { 4788 4788 + tonic::Status::unknown( 4789 4789 + format!("Service was not ready: {}", e.into()), 4790 4790 + ) 4791 4791 + })?; 4123 4792 let codec = tonic::codec::ProstCodec::default(); 4124 4793 let path = http::uri::PathAndQuery::from_static( 4125 4794 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks", 4126 4795 ); 4127 4796 let mut req = request.into_request(); 4128 4128 - req.extensions_mut().insert(GrpcMethod::new( 4129 4129 - "rockbox.v1alpha1.PlaylistService", 4130 4130 - "RemoveAllTracks", 4131 4131 - )); 4797 4797 + req.extensions_mut() 4798 4798 + .insert( 4799 4799 + GrpcMethod::new( 4800 4800 + "rockbox.v1alpha1.PlaylistService", 4801 4801 + "RemoveAllTracks", 4802 4802 + ), 4803 4803 + ); 4132 4804 self.inner.unary(req, path, codec).await 4133 4805 } 4134 4806 pub async fn remove_tracks( 4135 4807 &mut self, 4136 4808 request: impl tonic::IntoRequest<super::RemoveTracksRequest>, 4137 4137 - ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status> 4138 4138 - { 4139 4139 - self.inner.ready().await.map_err(|e| { 4140 4140 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4141 4141 - })?; 4809 4809 + ) -> std::result::Result< 4810 4810 + tonic::Response<super::RemoveTracksResponse>, 4811 4811 + tonic::Status, 4812 4812 + > { 4813 4813 + self.inner 4814 4814 + .ready() 4815 4815 + .await 4816 4816 + .map_err(|e| { 4817 4817 + tonic::Status::unknown( 4818 4818 + format!("Service was not ready: {}", e.into()), 4819 4819 + ) 4820 4820 + })?; 4142 4821 let codec = tonic::codec::ProstCodec::default(); 4143 4822 let path = http::uri::PathAndQuery::from_static( 4144 4823 "/rockbox.v1alpha1.PlaylistService/RemoveTracks", 4145 4824 ); 4146 4825 let mut req = request.into_request(); 4147 4147 - req.extensions_mut().insert(GrpcMethod::new( 4148 4148 - "rockbox.v1alpha1.PlaylistService", 4149 4149 - "RemoveTracks", 4150 4150 - )); 4826 4826 + req.extensions_mut() 4827 4827 + .insert( 4828 4828 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "RemoveTracks"), 4829 4829 + ); 4151 4830 self.inner.unary(req, path, codec).await 4152 4831 } 4153 4832 pub async fn create_playlist( 4154 4833 &mut self, 4155 4834 request: impl tonic::IntoRequest<super::CreatePlaylistRequest>, 4156 4156 - ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status> 4157 4157 - { 4158 4158 - self.inner.ready().await.map_err(|e| { 4159 4159 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4160 4160 - })?; 4835 4835 + ) -> std::result::Result< 4836 4836 + tonic::Response<super::CreatePlaylistResponse>, 4837 4837 + tonic::Status, 4838 4838 + > { 4839 4839 + self.inner 4840 4840 + .ready() 4841 4841 + .await 4842 4842 + .map_err(|e| { 4843 4843 + tonic::Status::unknown( 4844 4844 + format!("Service was not ready: {}", e.into()), 4845 4845 + ) 4846 4846 + })?; 4161 4847 let codec = tonic::codec::ProstCodec::default(); 4162 4848 let path = http::uri::PathAndQuery::from_static( 4163 4849 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist", 4164 4850 ); 4165 4851 let mut req = request.into_request(); 4166 4166 - req.extensions_mut().insert(GrpcMethod::new( 4167 4167 - "rockbox.v1alpha1.PlaylistService", 4168 4168 - "CreatePlaylist", 4169 4169 - )); 4852 4852 + req.extensions_mut() 4853 4853 + .insert( 4854 4854 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "CreatePlaylist"), 4855 4855 + ); 4170 4856 self.inner.unary(req, path, codec).await 4171 4857 } 4172 4858 pub async fn insert_tracks( 4173 4859 &mut self, 4174 4860 request: impl tonic::IntoRequest<super::InsertTracksRequest>, 4175 4175 - ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status> 4176 4176 - { 4177 4177 - self.inner.ready().await.map_err(|e| { 4178 4178 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4179 4179 - })?; 4861 4861 + ) -> std::result::Result< 4862 4862 + tonic::Response<super::InsertTracksResponse>, 4863 4863 + tonic::Status, 4864 4864 + > { 4865 4865 + self.inner 4866 4866 + .ready() 4867 4867 + .await 4868 4868 + .map_err(|e| { 4869 4869 + tonic::Status::unknown( 4870 4870 + format!("Service was not ready: {}", e.into()), 4871 4871 + ) 4872 4872 + })?; 4180 4873 let codec = tonic::codec::ProstCodec::default(); 4181 4874 let path = http::uri::PathAndQuery::from_static( 4182 4875 "/rockbox.v1alpha1.PlaylistService/InsertTracks", 4183 4876 ); 4184 4877 let mut req = request.into_request(); 4185 4185 - req.extensions_mut().insert(GrpcMethod::new( 4186 4186 - "rockbox.v1alpha1.PlaylistService", 4187 4187 - "InsertTracks", 4188 4188 - )); 4878 4878 + req.extensions_mut() 4879 4879 + .insert( 4880 4880 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertTracks"), 4881 4881 + ); 4189 4882 self.inner.unary(req, path, codec).await 4190 4883 } 4191 4884 pub async fn insert_directory( 4192 4885 &mut self, 4193 4886 request: impl tonic::IntoRequest<super::InsertDirectoryRequest>, 4194 4194 - ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status> 4195 4195 - { 4196 4196 - self.inner.ready().await.map_err(|e| { 4197 4197 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4198 4198 - })?; 4887 4887 + ) -> std::result::Result< 4888 4888 + tonic::Response<super::InsertDirectoryResponse>, 4889 4889 + tonic::Status, 4890 4890 + > { 4891 4891 + self.inner 4892 4892 + .ready() 4893 4893 + .await 4894 4894 + .map_err(|e| { 4895 4895 + tonic::Status::unknown( 4896 4896 + format!("Service was not ready: {}", e.into()), 4897 4897 + ) 4898 4898 + })?; 4199 4899 let codec = tonic::codec::ProstCodec::default(); 4200 4900 let path = http::uri::PathAndQuery::from_static( 4201 4901 "/rockbox.v1alpha1.PlaylistService/InsertDirectory", 4202 4902 ); 4203 4903 let mut req = request.into_request(); 4204 4204 - req.extensions_mut().insert(GrpcMethod::new( 4205 4205 - "rockbox.v1alpha1.PlaylistService", 4206 4206 - "InsertDirectory", 4207 4207 - )); 4904 4904 + req.extensions_mut() 4905 4905 + .insert( 4906 4906 + GrpcMethod::new( 4907 4907 + "rockbox.v1alpha1.PlaylistService", 4908 4908 + "InsertDirectory", 4909 4909 + ), 4910 4910 + ); 4208 4911 self.inner.unary(req, path, codec).await 4209 4912 } 4210 4913 pub async fn insert_playlist( 4211 4914 &mut self, 4212 4915 request: impl tonic::IntoRequest<super::InsertPlaylistRequest>, 4213 4213 - ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status> 4214 4214 - { 4215 4215 - self.inner.ready().await.map_err(|e| { 4216 4216 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4217 4217 - })?; 4916 4916 + ) -> std::result::Result< 4917 4917 + tonic::Response<super::InsertPlaylistResponse>, 4918 4918 + tonic::Status, 4919 4919 + > { 4920 4920 + self.inner 4921 4921 + .ready() 4922 4922 + .await 4923 4923 + .map_err(|e| { 4924 4924 + tonic::Status::unknown( 4925 4925 + format!("Service was not ready: {}", e.into()), 4926 4926 + ) 4927 4927 + })?; 4218 4928 let codec = tonic::codec::ProstCodec::default(); 4219 4929 let path = http::uri::PathAndQuery::from_static( 4220 4930 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist", 4221 4931 ); 4222 4932 let mut req = request.into_request(); 4223 4223 - req.extensions_mut().insert(GrpcMethod::new( 4224 4224 - "rockbox.v1alpha1.PlaylistService", 4225 4225 - "InsertPlaylist", 4226 4226 - )); 4933 4933 + req.extensions_mut() 4934 4934 + .insert( 4935 4935 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertPlaylist"), 4936 4936 + ); 4227 4937 self.inner.unary(req, path, codec).await 4228 4938 } 4229 4939 pub async fn insert_album( 4230 4940 &mut self, 4231 4941 request: impl tonic::IntoRequest<super::InsertAlbumRequest>, 4232 4232 - ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status> 4233 4233 - { 4234 4234 - self.inner.ready().await.map_err(|e| { 4235 4235 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4236 4236 - })?; 4942 4942 + ) -> std::result::Result< 4943 4943 + tonic::Response<super::InsertAlbumResponse>, 4944 4944 + tonic::Status, 4945 4945 + > { 4946 4946 + self.inner 4947 4947 + .ready() 4948 4948 + .await 4949 4949 + .map_err(|e| { 4950 4950 + tonic::Status::unknown( 4951 4951 + format!("Service was not ready: {}", e.into()), 4952 4952 + ) 4953 4953 + })?; 4237 4954 let codec = tonic::codec::ProstCodec::default(); 4238 4955 let path = http::uri::PathAndQuery::from_static( 4239 4956 "/rockbox.v1alpha1.PlaylistService/InsertAlbum", 4240 4957 ); 4241 4958 let mut req = request.into_request(); 4242 4242 - req.extensions_mut().insert(GrpcMethod::new( 4243 4243 - "rockbox.v1alpha1.PlaylistService", 4244 4244 - "InsertAlbum", 4245 4245 - )); 4959 4959 + req.extensions_mut() 4960 4960 + .insert( 4961 4961 + GrpcMethod::new("rockbox.v1alpha1.PlaylistService", "InsertAlbum"), 4962 4962 + ); 4246 4963 self.inner.unary(req, path, codec).await 4247 4964 } 4248 4965 pub async fn insert_artist_tracks( 4249 4966 &mut self, 4250 4967 request: impl tonic::IntoRequest<super::InsertArtistTracksRequest>, 4251 4251 - ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status> 4252 4252 - { 4253 4253 - self.inner.ready().await.map_err(|e| { 4254 4254 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4255 4255 - })?; 4968 4968 + ) -> std::result::Result< 4969 4969 + tonic::Response<super::InsertArtistTracksResponse>, 4970 4970 + tonic::Status, 4971 4971 + > { 4972 4972 + self.inner 4973 4973 + .ready() 4974 4974 + .await 4975 4975 + .map_err(|e| { 4976 4976 + tonic::Status::unknown( 4977 4977 + format!("Service was not ready: {}", e.into()), 4978 4978 + ) 4979 4979 + })?; 4256 4980 let codec = tonic::codec::ProstCodec::default(); 4257 4981 let path = http::uri::PathAndQuery::from_static( 4258 4982 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks", 4259 4983 ); 4260 4984 let mut req = request.into_request(); 4261 4261 - req.extensions_mut().insert(GrpcMethod::new( 4262 4262 - "rockbox.v1alpha1.PlaylistService", 4263 4263 - "InsertArtistTracks", 4264 4264 - )); 4985 4985 + req.extensions_mut() 4986 4986 + .insert( 4987 4987 + GrpcMethod::new( 4988 4988 + "rockbox.v1alpha1.PlaylistService", 4989 4989 + "InsertArtistTracks", 4990 4990 + ), 4991 4991 + ); 4265 4992 self.inner.unary(req, path, codec).await 4266 4993 } 4267 4994 pub async fn shuffle_playlist( 4268 4995 &mut self, 4269 4996 request: impl tonic::IntoRequest<super::ShufflePlaylistRequest>, 4270 4270 - ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status> 4271 4271 - { 4272 4272 - self.inner.ready().await.map_err(|e| { 4273 4273 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 4274 4274 - })?; 4997 4997 + ) -> std::result::Result< 4998 4998 + tonic::Response<super::ShufflePlaylistResponse>, 4999 4999 + tonic::Status, 5000 5000 + > { 5001 5001 + self.inner 5002 5002 + .ready() 5003 5003 + .await 5004 5004 + .map_err(|e| { 5005 5005 + tonic::Status::unknown( 5006 5006 + format!("Service was not ready: {}", e.into()), 5007 5007 + ) 5008 5008 + })?; 4275 5009 let codec = tonic::codec::ProstCodec::default(); 4276 5010 let path = http::uri::PathAndQuery::from_static( 4277 5011 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist", 4278 5012 ); 4279 5013 let mut req = request.into_request(); 4280 4280 - req.extensions_mut().insert(GrpcMethod::new( 4281 4281 - "rockbox.v1alpha1.PlaylistService", 4282 4282 - "ShufflePlaylist", 4283 4283 - )); 5014 5014 + req.extensions_mut() 5015 5015 + .insert( 5016 5016 + GrpcMethod::new( 5017 5017 + "rockbox.v1alpha1.PlaylistService", 5018 5018 + "ShufflePlaylist", 5019 5019 + ), 5020 5020 + ); 4284 5021 self.inner.unary(req, path, codec).await 4285 5022 } 4286 5023 } ··· 4292 5029 dead_code, 4293 5030 missing_docs, 4294 5031 clippy::wildcard_imports, 4295 4295 - clippy::let_unit_value 5032 5032 + clippy::let_unit_value, 4296 5033 )] 4297 5034 use tonic::codegen::*; 4298 5035 /// Generated trait containing gRPC methods that should be implemented for use with PlaylistServiceServer. ··· 4301 5038 async fn get_current( 4302 5039 &self, 4303 5040 request: tonic::Request<super::GetCurrentRequest>, 4304 4304 - ) -> std::result::Result<tonic::Response<super::GetCurrentResponse>, tonic::Status>; 5041 5041 + ) -> std::result::Result< 5042 5042 + tonic::Response<super::GetCurrentResponse>, 5043 5043 + tonic::Status, 5044 5044 + >; 4305 5045 async fn get_resume_info( 4306 5046 &self, 4307 5047 request: tonic::Request<super::GetResumeInfoRequest>, 4308 4308 - ) -> std::result::Result<tonic::Response<super::GetResumeInfoResponse>, tonic::Status>; 5048 5048 + ) -> std::result::Result< 5049 5049 + tonic::Response<super::GetResumeInfoResponse>, 5050 5050 + tonic::Status, 5051 5051 + >; 4309 5052 async fn get_track_info( 4310 5053 &self, 4311 5054 request: tonic::Request<super::GetTrackInfoRequest>, 4312 4312 - ) -> std::result::Result<tonic::Response<super::GetTrackInfoResponse>, tonic::Status>; 5055 5055 + ) -> std::result::Result< 5056 5056 + tonic::Response<super::GetTrackInfoResponse>, 5057 5057 + tonic::Status, 5058 5058 + >; 4313 5059 async fn get_first_index( 4314 5060 &self, 4315 5061 request: tonic::Request<super::GetFirstIndexRequest>, 4316 4316 - ) -> std::result::Result<tonic::Response<super::GetFirstIndexResponse>, tonic::Status>; 5062 5062 + ) -> std::result::Result< 5063 5063 + tonic::Response<super::GetFirstIndexResponse>, 5064 5064 + tonic::Status, 5065 5065 + >; 4317 5066 async fn get_display_index( 4318 5067 &self, 4319 5068 request: tonic::Request<super::GetDisplayIndexRequest>, 4320 4320 - ) -> std::result::Result<tonic::Response<super::GetDisplayIndexResponse>, tonic::Status>; 5069 5069 + ) -> std::result::Result< 5070 5070 + tonic::Response<super::GetDisplayIndexResponse>, 5071 5071 + tonic::Status, 5072 5072 + >; 4321 5073 async fn amount( 4322 5074 &self, 4323 5075 request: tonic::Request<super::AmountRequest>, ··· 4325 5077 async fn playlist_resume( 4326 5078 &self, 4327 5079 request: tonic::Request<super::PlaylistResumeRequest>, 4328 4328 - ) -> std::result::Result<tonic::Response<super::PlaylistResumeResponse>, tonic::Status>; 5080 5080 + ) -> std::result::Result< 5081 5081 + tonic::Response<super::PlaylistResumeResponse>, 5082 5082 + tonic::Status, 5083 5083 + >; 4329 5084 async fn resume_track( 4330 5085 &self, 4331 5086 request: tonic::Request<super::ResumeTrackRequest>, 4332 4332 - ) -> std::result::Result<tonic::Response<super::ResumeTrackResponse>, tonic::Status>; 5087 5087 + ) -> std::result::Result< 5088 5088 + tonic::Response<super::ResumeTrackResponse>, 5089 5089 + tonic::Status, 5090 5090 + >; 4333 5091 async fn set_modified( 4334 5092 &self, 4335 5093 request: tonic::Request<super::SetModifiedRequest>, 4336 4336 - ) -> std::result::Result<tonic::Response<super::SetModifiedResponse>, tonic::Status>; 5094 5094 + ) -> std::result::Result< 5095 5095 + tonic::Response<super::SetModifiedResponse>, 5096 5096 + tonic::Status, 5097 5097 + >; 4337 5098 async fn start( 4338 5099 &self, 4339 5100 request: tonic::Request<super::StartRequest>, ··· 4345 5106 async fn remove_all_tracks( 4346 5107 &self, 4347 5108 request: tonic::Request<super::RemoveAllTracksRequest>, 4348 4348 - ) -> std::result::Result<tonic::Response<super::RemoveAllTracksResponse>, tonic::Status>; 5109 5109 + ) -> std::result::Result< 5110 5110 + tonic::Response<super::RemoveAllTracksResponse>, 5111 5111 + tonic::Status, 5112 5112 + >; 4349 5113 async fn remove_tracks( 4350 5114 &self, 4351 5115 request: tonic::Request<super::RemoveTracksRequest>, 4352 4352 - ) -> std::result::Result<tonic::Response<super::RemoveTracksResponse>, tonic::Status>; 5116 5116 + ) -> std::result::Result< 5117 5117 + tonic::Response<super::RemoveTracksResponse>, 5118 5118 + tonic::Status, 5119 5119 + >; 4353 5120 async fn create_playlist( 4354 5121 &self, 4355 5122 request: tonic::Request<super::CreatePlaylistRequest>, 4356 4356 - ) -> std::result::Result<tonic::Response<super::CreatePlaylistResponse>, tonic::Status>; 5123 5123 + ) -> std::result::Result< 5124 5124 + tonic::Response<super::CreatePlaylistResponse>, 5125 5125 + tonic::Status, 5126 5126 + >; 4357 5127 async fn insert_tracks( 4358 5128 &self, 4359 5129 request: tonic::Request<super::InsertTracksRequest>, 4360 4360 - ) -> std::result::Result<tonic::Response<super::InsertTracksResponse>, tonic::Status>; 5130 5130 + ) -> std::result::Result< 5131 5131 + tonic::Response<super::InsertTracksResponse>, 5132 5132 + tonic::Status, 5133 5133 + >; 4361 5134 async fn insert_directory( 4362 5135 &self, 4363 5136 request: tonic::Request<super::InsertDirectoryRequest>, 4364 4364 - ) -> std::result::Result<tonic::Response<super::InsertDirectoryResponse>, tonic::Status>; 5137 5137 + ) -> std::result::Result< 5138 5138 + tonic::Response<super::InsertDirectoryResponse>, 5139 5139 + tonic::Status, 5140 5140 + >; 4365 5141 async fn insert_playlist( 4366 5142 &self, 4367 5143 request: tonic::Request<super::InsertPlaylistRequest>, 4368 4368 - ) -> std::result::Result<tonic::Response<super::InsertPlaylistResponse>, tonic::Status>; 5144 5144 + ) -> std::result::Result< 5145 5145 + tonic::Response<super::InsertPlaylistResponse>, 5146 5146 + tonic::Status, 5147 5147 + >; 4369 5148 async fn insert_album( 4370 5149 &self, 4371 5150 request: tonic::Request<super::InsertAlbumRequest>, 4372 4372 - ) -> std::result::Result<tonic::Response<super::InsertAlbumResponse>, tonic::Status>; 5151 5151 + ) -> std::result::Result< 5152 5152 + tonic::Response<super::InsertAlbumResponse>, 5153 5153 + tonic::Status, 5154 5154 + >; 4373 5155 async fn insert_artist_tracks( 4374 5156 &self, 4375 5157 request: tonic::Request<super::InsertArtistTracksRequest>, 4376 4376 - ) -> std::result::Result<tonic::Response<super::InsertArtistTracksResponse>, tonic::Status>; 5158 5158 + ) -> std::result::Result< 5159 5159 + tonic::Response<super::InsertArtistTracksResponse>, 5160 5160 + tonic::Status, 5161 5161 + >; 4377 5162 async fn shuffle_playlist( 4378 5163 &self, 4379 5164 request: tonic::Request<super::ShufflePlaylistRequest>, 4380 4380 - ) -> std::result::Result<tonic::Response<super::ShufflePlaylistResponse>, tonic::Status>; 5165 5165 + ) -> std::result::Result< 5166 5166 + tonic::Response<super::ShufflePlaylistResponse>, 5167 5167 + tonic::Status, 5168 5168 + >; 4381 5169 } 4382 5170 #[derive(Debug)] 4383 5171 pub struct PlaylistServiceServer<T> { ··· 4400 5188 max_encoding_message_size: None, 4401 5189 } 4402 5190 } 4403 4403 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 5191 5191 + pub fn with_interceptor<F>( 5192 5192 + inner: T, 5193 5193 + interceptor: F, 5194 5194 + ) -> InterceptedService<Self, F> 4404 5195 where 4405 5196 F: tonic::service::Interceptor, 4406 5197 { ··· 4455 5246 "/rockbox.v1alpha1.PlaylistService/GetCurrent" => { 4456 5247 #[allow(non_camel_case_types)] 4457 5248 struct GetCurrentSvc<T: PlaylistService>(pub Arc<T>); 4458 4458 - impl<T: PlaylistService> tonic::server::UnaryService<super::GetCurrentRequest> 4459 4459 - for GetCurrentSvc<T> 4460 4460 - { 5249 5249 + impl< 5250 5250 + T: PlaylistService, 5251 5251 + > tonic::server::UnaryService<super::GetCurrentRequest> 5252 5252 + for GetCurrentSvc<T> { 4461 5253 type Response = super::GetCurrentResponse; 4462 4462 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5254 5254 + type Future = BoxFuture< 5255 5255 + tonic::Response<Self::Response>, 5256 5256 + tonic::Status, 5257 5257 + >; 4463 5258 fn call( 4464 5259 &mut self, 4465 5260 request: tonic::Request<super::GetCurrentRequest>, ··· 4496 5291 "/rockbox.v1alpha1.PlaylistService/GetResumeInfo" => { 4497 5292 #[allow(non_camel_case_types)] 4498 5293 struct GetResumeInfoSvc<T: PlaylistService>(pub Arc<T>); 4499 4499 - impl<T: PlaylistService> 4500 4500 - tonic::server::UnaryService<super::GetResumeInfoRequest> 4501 4501 - for GetResumeInfoSvc<T> 4502 4502 - { 5294 5294 + impl< 5295 5295 + T: PlaylistService, 5296 5296 + > tonic::server::UnaryService<super::GetResumeInfoRequest> 5297 5297 + for GetResumeInfoSvc<T> { 4503 5298 type Response = super::GetResumeInfoResponse; 4504 4504 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5299 5299 + type Future = BoxFuture< 5300 5300 + tonic::Response<Self::Response>, 5301 5301 + tonic::Status, 5302 5302 + >; 4505 5303 fn call( 4506 5304 &mut self, 4507 5305 request: tonic::Request<super::GetResumeInfoRequest>, 4508 5306 ) -> Self::Future { 4509 5307 let inner = Arc::clone(&self.0); 4510 5308 let fut = async move { 4511 4511 - <T as PlaylistService>::get_resume_info(&inner, request).await 5309 5309 + <T as PlaylistService>::get_resume_info(&inner, request) 5310 5310 + .await 4512 5311 }; 4513 5312 Box::pin(fut) 4514 5313 } ··· 4538 5337 "/rockbox.v1alpha1.PlaylistService/GetTrackInfo" => { 4539 5338 #[allow(non_camel_case_types)] 4540 5339 struct GetTrackInfoSvc<T: PlaylistService>(pub Arc<T>); 4541 4541 - impl<T: PlaylistService> tonic::server::UnaryService<super::GetTrackInfoRequest> 4542 4542 - for GetTrackInfoSvc<T> 4543 4543 - { 5340 5340 + impl< 5341 5341 + T: PlaylistService, 5342 5342 + > tonic::server::UnaryService<super::GetTrackInfoRequest> 5343 5343 + for GetTrackInfoSvc<T> { 4544 5344 type Response = super::GetTrackInfoResponse; 4545 4545 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5345 5345 + type Future = BoxFuture< 5346 5346 + tonic::Response<Self::Response>, 5347 5347 + tonic::Status, 5348 5348 + >; 4546 5349 fn call( 4547 5350 &mut self, 4548 5351 request: tonic::Request<super::GetTrackInfoRequest>, 4549 5352 ) -> Self::Future { 4550 5353 let inner = Arc::clone(&self.0); 4551 5354 let fut = async move { 4552 4552 - <T as PlaylistService>::get_track_info(&inner, request).await 5355 5355 + <T as PlaylistService>::get_track_info(&inner, request) 5356 5356 + .await 4553 5357 }; 4554 5358 Box::pin(fut) 4555 5359 } ··· 4579 5383 "/rockbox.v1alpha1.PlaylistService/GetFirstIndex" => { 4580 5384 #[allow(non_camel_case_types)] 4581 5385 struct GetFirstIndexSvc<T: PlaylistService>(pub Arc<T>); 4582 4582 - impl<T: PlaylistService> 4583 4583 - tonic::server::UnaryService<super::GetFirstIndexRequest> 4584 4584 - for GetFirstIndexSvc<T> 4585 4585 - { 5386 5386 + impl< 5387 5387 + T: PlaylistService, 5388 5388 + > tonic::server::UnaryService<super::GetFirstIndexRequest> 5389 5389 + for GetFirstIndexSvc<T> { 4586 5390 type Response = super::GetFirstIndexResponse; 4587 4587 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5391 5391 + type Future = BoxFuture< 5392 5392 + tonic::Response<Self::Response>, 5393 5393 + tonic::Status, 5394 5394 + >; 4588 5395 fn call( 4589 5396 &mut self, 4590 5397 request: tonic::Request<super::GetFirstIndexRequest>, 4591 5398 ) -> Self::Future { 4592 5399 let inner = Arc::clone(&self.0); 4593 5400 let fut = async move { 4594 4594 - <T as PlaylistService>::get_first_index(&inner, request).await 5401 5401 + <T as PlaylistService>::get_first_index(&inner, request) 5402 5402 + .await 4595 5403 }; 4596 5404 Box::pin(fut) 4597 5405 } ··· 4621 5429 "/rockbox.v1alpha1.PlaylistService/GetDisplayIndex" => { 4622 5430 #[allow(non_camel_case_types)] 4623 5431 struct GetDisplayIndexSvc<T: PlaylistService>(pub Arc<T>); 4624 4624 - impl<T: PlaylistService> 4625 4625 - tonic::server::UnaryService<super::GetDisplayIndexRequest> 4626 4626 - for GetDisplayIndexSvc<T> 4627 4627 - { 5432 5432 + impl< 5433 5433 + T: PlaylistService, 5434 5434 + > tonic::server::UnaryService<super::GetDisplayIndexRequest> 5435 5435 + for GetDisplayIndexSvc<T> { 4628 5436 type Response = super::GetDisplayIndexResponse; 4629 4629 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5437 5437 + type Future = BoxFuture< 5438 5438 + tonic::Response<Self::Response>, 5439 5439 + tonic::Status, 5440 5440 + >; 4630 5441 fn call( 4631 5442 &mut self, 4632 5443 request: tonic::Request<super::GetDisplayIndexRequest>, 4633 5444 ) -> Self::Future { 4634 5445 let inner = Arc::clone(&self.0); 4635 5446 let fut = async move { 4636 4636 - <T as PlaylistService>::get_display_index(&inner, request).await 5447 5447 + <T as PlaylistService>::get_display_index(&inner, request) 5448 5448 + .await 4637 5449 }; 4638 5450 Box::pin(fut) 4639 5451 } ··· 4663 5475 "/rockbox.v1alpha1.PlaylistService/Amount" => { 4664 5476 #[allow(non_camel_case_types)] 4665 5477 struct AmountSvc<T: PlaylistService>(pub Arc<T>); 4666 4666 - impl<T: PlaylistService> tonic::server::UnaryService<super::AmountRequest> for AmountSvc<T> { 5478 5478 + impl< 5479 5479 + T: PlaylistService, 5480 5480 + > tonic::server::UnaryService<super::AmountRequest> 5481 5481 + for AmountSvc<T> { 4667 5482 type Response = super::AmountResponse; 4668 4668 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5483 5483 + type Future = BoxFuture< 5484 5484 + tonic::Response<Self::Response>, 5485 5485 + tonic::Status, 5486 5486 + >; 4669 5487 fn call( 4670 5488 &mut self, 4671 5489 request: tonic::Request<super::AmountRequest>, ··· 4702 5520 "/rockbox.v1alpha1.PlaylistService/PlaylistResume" => { 4703 5521 #[allow(non_camel_case_types)] 4704 5522 struct PlaylistResumeSvc<T: PlaylistService>(pub Arc<T>); 4705 4705 - impl<T: PlaylistService> 4706 4706 - tonic::server::UnaryService<super::PlaylistResumeRequest> 4707 4707 - for PlaylistResumeSvc<T> 4708 4708 - { 5523 5523 + impl< 5524 5524 + T: PlaylistService, 5525 5525 + > tonic::server::UnaryService<super::PlaylistResumeRequest> 5526 5526 + for PlaylistResumeSvc<T> { 4709 5527 type Response = super::PlaylistResumeResponse; 4710 4710 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5528 5528 + type Future = BoxFuture< 5529 5529 + tonic::Response<Self::Response>, 5530 5530 + tonic::Status, 5531 5531 + >; 4711 5532 fn call( 4712 5533 &mut self, 4713 5534 request: tonic::Request<super::PlaylistResumeRequest>, 4714 5535 ) -> Self::Future { 4715 5536 let inner = Arc::clone(&self.0); 4716 5537 let fut = async move { 4717 4717 - <T as PlaylistService>::playlist_resume(&inner, request).await 5538 5538 + <T as PlaylistService>::playlist_resume(&inner, request) 5539 5539 + .await 4718 5540 }; 4719 5541 Box::pin(fut) 4720 5542 } ··· 4744 5566 "/rockbox.v1alpha1.PlaylistService/ResumeTrack" => { 4745 5567 #[allow(non_camel_case_types)] 4746 5568 struct ResumeTrackSvc<T: PlaylistService>(pub Arc<T>); 4747 4747 - impl<T: PlaylistService> tonic::server::UnaryService<super::ResumeTrackRequest> 4748 4748 - for ResumeTrackSvc<T> 4749 4749 - { 5569 5569 + impl< 5570 5570 + T: PlaylistService, 5571 5571 + > tonic::server::UnaryService<super::ResumeTrackRequest> 5572 5572 + for ResumeTrackSvc<T> { 4750 5573 type Response = super::ResumeTrackResponse; 4751 4751 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5574 5574 + type Future = BoxFuture< 5575 5575 + tonic::Response<Self::Response>, 5576 5576 + tonic::Status, 5577 5577 + >; 4752 5578 fn call( 4753 5579 &mut self, 4754 5580 request: tonic::Request<super::ResumeTrackRequest>, ··· 4785 5611 "/rockbox.v1alpha1.PlaylistService/SetModified" => { 4786 5612 #[allow(non_camel_case_types)] 4787 5613 struct SetModifiedSvc<T: PlaylistService>(pub Arc<T>); 4788 4788 - impl<T: PlaylistService> tonic::server::UnaryService<super::SetModifiedRequest> 4789 4789 - for SetModifiedSvc<T> 4790 4790 - { 5614 5614 + impl< 5615 5615 + T: PlaylistService, 5616 5616 + > tonic::server::UnaryService<super::SetModifiedRequest> 5617 5617 + for SetModifiedSvc<T> { 4791 5618 type Response = super::SetModifiedResponse; 4792 4792 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5619 5619 + type Future = BoxFuture< 5620 5620 + tonic::Response<Self::Response>, 5621 5621 + tonic::Status, 5622 5622 + >; 4793 5623 fn call( 4794 5624 &mut self, 4795 5625 request: tonic::Request<super::SetModifiedRequest>, ··· 4826 5656 "/rockbox.v1alpha1.PlaylistService/Start" => { 4827 5657 #[allow(non_camel_case_types)] 4828 5658 struct StartSvc<T: PlaylistService>(pub Arc<T>); 4829 4829 - impl<T: PlaylistService> tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 5659 5659 + impl< 5660 5660 + T: PlaylistService, 5661 5661 + > tonic::server::UnaryService<super::StartRequest> for StartSvc<T> { 4830 5662 type Response = super::StartResponse; 4831 4831 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5663 5663 + type Future = BoxFuture< 5664 5664 + tonic::Response<Self::Response>, 5665 5665 + tonic::Status, 5666 5666 + >; 4832 5667 fn call( 4833 5668 &mut self, 4834 5669 request: tonic::Request<super::StartRequest>, 4835 5670 ) -> Self::Future { 4836 5671 let inner = Arc::clone(&self.0); 4837 4837 - let fut = 4838 4838 - async move { <T as PlaylistService>::start(&inner, request).await }; 5672 5672 + let fut = async move { 5673 5673 + <T as PlaylistService>::start(&inner, request).await 5674 5674 + }; 4839 5675 Box::pin(fut) 4840 5676 } 4841 5677 } ··· 4864 5700 "/rockbox.v1alpha1.PlaylistService/Sync" => { 4865 5701 #[allow(non_camel_case_types)] 4866 5702 struct SyncSvc<T: PlaylistService>(pub Arc<T>); 4867 4867 - impl<T: PlaylistService> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 5703 5703 + impl< 5704 5704 + T: PlaylistService, 5705 5705 + > tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> { 4868 5706 type Response = super::SyncResponse; 4869 4869 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5707 5707 + type Future = BoxFuture< 5708 5708 + tonic::Response<Self::Response>, 5709 5709 + tonic::Status, 5710 5710 + >; 4870 5711 fn call( 4871 5712 &mut self, 4872 5713 request: tonic::Request<super::SyncRequest>, 4873 5714 ) -> Self::Future { 4874 5715 let inner = Arc::clone(&self.0); 4875 4875 - let fut = 4876 4876 - async move { <T as PlaylistService>::sync(&inner, request).await }; 5716 5716 + let fut = async move { 5717 5717 + <T as PlaylistService>::sync(&inner, request).await 5718 5718 + }; 4877 5719 Box::pin(fut) 4878 5720 } 4879 5721 } ··· 4902 5744 "/rockbox.v1alpha1.PlaylistService/RemoveAllTracks" => { 4903 5745 #[allow(non_camel_case_types)] 4904 5746 struct RemoveAllTracksSvc<T: PlaylistService>(pub Arc<T>); 4905 4905 - impl<T: PlaylistService> 4906 4906 - tonic::server::UnaryService<super::RemoveAllTracksRequest> 4907 4907 - for RemoveAllTracksSvc<T> 4908 4908 - { 5747 5747 + impl< 5748 5748 + T: PlaylistService, 5749 5749 + > tonic::server::UnaryService<super::RemoveAllTracksRequest> 5750 5750 + for RemoveAllTracksSvc<T> { 4909 5751 type Response = super::RemoveAllTracksResponse; 4910 4910 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5752 5752 + type Future = BoxFuture< 5753 5753 + tonic::Response<Self::Response>, 5754 5754 + tonic::Status, 5755 5755 + >; 4911 5756 fn call( 4912 5757 &mut self, 4913 5758 request: tonic::Request<super::RemoveAllTracksRequest>, 4914 5759 ) -> Self::Future { 4915 5760 let inner = Arc::clone(&self.0); 4916 5761 let fut = async move { 4917 4917 - <T as PlaylistService>::remove_all_tracks(&inner, request).await 5762 5762 + <T as PlaylistService>::remove_all_tracks(&inner, request) 5763 5763 + .await 4918 5764 }; 4919 5765 Box::pin(fut) 4920 5766 } ··· 4944 5790 "/rockbox.v1alpha1.PlaylistService/RemoveTracks" => { 4945 5791 #[allow(non_camel_case_types)] 4946 5792 struct RemoveTracksSvc<T: PlaylistService>(pub Arc<T>); 4947 4947 - impl<T: PlaylistService> tonic::server::UnaryService<super::RemoveTracksRequest> 4948 4948 - for RemoveTracksSvc<T> 4949 4949 - { 5793 5793 + impl< 5794 5794 + T: PlaylistService, 5795 5795 + > tonic::server::UnaryService<super::RemoveTracksRequest> 5796 5796 + for RemoveTracksSvc<T> { 4950 5797 type Response = super::RemoveTracksResponse; 4951 4951 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5798 5798 + type Future = BoxFuture< 5799 5799 + tonic::Response<Self::Response>, 5800 5800 + tonic::Status, 5801 5801 + >; 4952 5802 fn call( 4953 5803 &mut self, 4954 5804 request: tonic::Request<super::RemoveTracksRequest>, ··· 4985 5835 "/rockbox.v1alpha1.PlaylistService/CreatePlaylist" => { 4986 5836 #[allow(non_camel_case_types)] 4987 5837 struct CreatePlaylistSvc<T: PlaylistService>(pub Arc<T>); 4988 4988 - impl<T: PlaylistService> 4989 4989 - tonic::server::UnaryService<super::CreatePlaylistRequest> 4990 4990 - for CreatePlaylistSvc<T> 4991 4991 - { 5838 5838 + impl< 5839 5839 + T: PlaylistService, 5840 5840 + > tonic::server::UnaryService<super::CreatePlaylistRequest> 5841 5841 + for CreatePlaylistSvc<T> { 4992 5842 type Response = super::CreatePlaylistResponse; 4993 4993 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5843 5843 + type Future = BoxFuture< 5844 5844 + tonic::Response<Self::Response>, 5845 5845 + tonic::Status, 5846 5846 + >; 4994 5847 fn call( 4995 5848 &mut self, 4996 5849 request: tonic::Request<super::CreatePlaylistRequest>, 4997 5850 ) -> Self::Future { 4998 5851 let inner = Arc::clone(&self.0); 4999 5852 let fut = async move { 5000 5000 - <T as PlaylistService>::create_playlist(&inner, request).await 5853 5853 + <T as PlaylistService>::create_playlist(&inner, request) 5854 5854 + .await 5001 5855 }; 5002 5856 Box::pin(fut) 5003 5857 } ··· 5027 5881 "/rockbox.v1alpha1.PlaylistService/InsertTracks" => { 5028 5882 #[allow(non_camel_case_types)] 5029 5883 struct InsertTracksSvc<T: PlaylistService>(pub Arc<T>); 5030 5030 - impl<T: PlaylistService> tonic::server::UnaryService<super::InsertTracksRequest> 5031 5031 - for InsertTracksSvc<T> 5032 5032 - { 5884 5884 + impl< 5885 5885 + T: PlaylistService, 5886 5886 + > tonic::server::UnaryService<super::InsertTracksRequest> 5887 5887 + for InsertTracksSvc<T> { 5033 5888 type Response = super::InsertTracksResponse; 5034 5034 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5889 5889 + type Future = BoxFuture< 5890 5890 + tonic::Response<Self::Response>, 5891 5891 + tonic::Status, 5892 5892 + >; 5035 5893 fn call( 5036 5894 &mut self, 5037 5895 request: tonic::Request<super::InsertTracksRequest>, ··· 5068 5926 "/rockbox.v1alpha1.PlaylistService/InsertDirectory" => { 5069 5927 #[allow(non_camel_case_types)] 5070 5928 struct InsertDirectorySvc<T: PlaylistService>(pub Arc<T>); 5071 5071 - impl<T: PlaylistService> 5072 5072 - tonic::server::UnaryService<super::InsertDirectoryRequest> 5073 5073 - for InsertDirectorySvc<T> 5074 5074 - { 5929 5929 + impl< 5930 5930 + T: PlaylistService, 5931 5931 + > tonic::server::UnaryService<super::InsertDirectoryRequest> 5932 5932 + for InsertDirectorySvc<T> { 5075 5933 type Response = super::InsertDirectoryResponse; 5076 5076 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5934 5934 + type Future = BoxFuture< 5935 5935 + tonic::Response<Self::Response>, 5936 5936 + tonic::Status, 5937 5937 + >; 5077 5938 fn call( 5078 5939 &mut self, 5079 5940 request: tonic::Request<super::InsertDirectoryRequest>, 5080 5941 ) -> Self::Future { 5081 5942 let inner = Arc::clone(&self.0); 5082 5943 let fut = async move { 5083 5083 - <T as PlaylistService>::insert_directory(&inner, request).await 5944 5944 + <T as PlaylistService>::insert_directory(&inner, request) 5945 5945 + .await 5084 5946 }; 5085 5947 Box::pin(fut) 5086 5948 } ··· 5110 5972 "/rockbox.v1alpha1.PlaylistService/InsertPlaylist" => { 5111 5973 #[allow(non_camel_case_types)] 5112 5974 struct InsertPlaylistSvc<T: PlaylistService>(pub Arc<T>); 5113 5113 - impl<T: PlaylistService> 5114 5114 - tonic::server::UnaryService<super::InsertPlaylistRequest> 5115 5115 - for InsertPlaylistSvc<T> 5116 5116 - { 5975 5975 + impl< 5976 5976 + T: PlaylistService, 5977 5977 + > tonic::server::UnaryService<super::InsertPlaylistRequest> 5978 5978 + for InsertPlaylistSvc<T> { 5117 5979 type Response = super::InsertPlaylistResponse; 5118 5118 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 5980 5980 + type Future = BoxFuture< 5981 5981 + tonic::Response<Self::Response>, 5982 5982 + tonic::Status, 5983 5983 + >; 5119 5984 fn call( 5120 5985 &mut self, 5121 5986 request: tonic::Request<super::InsertPlaylistRequest>, 5122 5987 ) -> Self::Future { 5123 5988 let inner = Arc::clone(&self.0); 5124 5989 let fut = async move { 5125 5125 - <T as PlaylistService>::insert_playlist(&inner, request).await 5990 5990 + <T as PlaylistService>::insert_playlist(&inner, request) 5991 5991 + .await 5126 5992 }; 5127 5993 Box::pin(fut) 5128 5994 } ··· 5152 6018 "/rockbox.v1alpha1.PlaylistService/InsertAlbum" => { 5153 6019 #[allow(non_camel_case_types)] 5154 6020 struct InsertAlbumSvc<T: PlaylistService>(pub Arc<T>); 5155 5155 - impl<T: PlaylistService> tonic::server::UnaryService<super::InsertAlbumRequest> 5156 5156 - for InsertAlbumSvc<T> 5157 5157 - { 6021 6021 + impl< 6022 6022 + T: PlaylistService, 6023 6023 + > tonic::server::UnaryService<super::InsertAlbumRequest> 6024 6024 + for InsertAlbumSvc<T> { 5158 6025 type Response = super::InsertAlbumResponse; 5159 5159 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6026 6026 + type Future = BoxFuture< 6027 6027 + tonic::Response<Self::Response>, 6028 6028 + tonic::Status, 6029 6029 + >; 5160 6030 fn call( 5161 6031 &mut self, 5162 6032 request: tonic::Request<super::InsertAlbumRequest>, ··· 5193 6063 "/rockbox.v1alpha1.PlaylistService/InsertArtistTracks" => { 5194 6064 #[allow(non_camel_case_types)] 5195 6065 struct InsertArtistTracksSvc<T: PlaylistService>(pub Arc<T>); 5196 5196 - impl<T: PlaylistService> 5197 5197 - tonic::server::UnaryService<super::InsertArtistTracksRequest> 5198 5198 - for InsertArtistTracksSvc<T> 5199 5199 - { 6066 6066 + impl< 6067 6067 + T: PlaylistService, 6068 6068 + > tonic::server::UnaryService<super::InsertArtistTracksRequest> 6069 6069 + for InsertArtistTracksSvc<T> { 5200 6070 type Response = super::InsertArtistTracksResponse; 5201 5201 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6071 6071 + type Future = BoxFuture< 6072 6072 + tonic::Response<Self::Response>, 6073 6073 + tonic::Status, 6074 6074 + >; 5202 6075 fn call( 5203 6076 &mut self, 5204 6077 request: tonic::Request<super::InsertArtistTracksRequest>, 5205 6078 ) -> Self::Future { 5206 6079 let inner = Arc::clone(&self.0); 5207 6080 let fut = async move { 5208 5208 - <T as PlaylistService>::insert_artist_tracks(&inner, request).await 6081 6081 + <T as PlaylistService>::insert_artist_tracks( 6082 6082 + &inner, 6083 6083 + request, 6084 6084 + ) 6085 6085 + .await 5209 6086 }; 5210 6087 Box::pin(fut) 5211 6088 } ··· 5235 6112 "/rockbox.v1alpha1.PlaylistService/ShufflePlaylist" => { 5236 6113 #[allow(non_camel_case_types)] 5237 6114 struct ShufflePlaylistSvc<T: PlaylistService>(pub Arc<T>); 5238 5238 - impl<T: PlaylistService> 5239 5239 - tonic::server::UnaryService<super::ShufflePlaylistRequest> 5240 5240 - for ShufflePlaylistSvc<T> 5241 5241 - { 6115 6115 + impl< 6116 6116 + T: PlaylistService, 6117 6117 + > tonic::server::UnaryService<super::ShufflePlaylistRequest> 6118 6118 + for ShufflePlaylistSvc<T> { 5242 6119 type Response = super::ShufflePlaylistResponse; 5243 5243 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6120 6120 + type Future = BoxFuture< 6121 6121 + tonic::Response<Self::Response>, 6122 6122 + tonic::Status, 6123 6123 + >; 5244 6124 fn call( 5245 6125 &mut self, 5246 6126 request: tonic::Request<super::ShufflePlaylistRequest>, 5247 6127 ) -> Self::Future { 5248 6128 let inner = Arc::clone(&self.0); 5249 6129 let fut = async move { 5250 5250 - <T as PlaylistService>::shuffle_playlist(&inner, request).await 6130 6130 + <T as PlaylistService>::shuffle_playlist(&inner, request) 6131 6131 + .await 5251 6132 }; 5252 6133 Box::pin(fut) 5253 6134 } ··· 5274 6155 }; 5275 6156 Box::pin(fut) 5276 6157 } 5277 5277 - _ => Box::pin(async move { 5278 5278 - let mut response = http::Response::new(empty_body()); 5279 5279 - let headers = response.headers_mut(); 5280 5280 - headers.insert( 5281 5281 - tonic::Status::GRPC_STATUS, 5282 5282 - (tonic::Code::Unimplemented as i32).into(), 5283 5283 - ); 5284 5284 - headers.insert( 5285 5285 - http::header::CONTENT_TYPE, 5286 5286 - tonic::metadata::GRPC_CONTENT_TYPE, 5287 5287 - ); 5288 5288 - Ok(response) 5289 5289 - }), 6158 6158 + _ => { 6159 6159 + Box::pin(async move { 6160 6160 + let mut response = http::Response::new(empty_body()); 6161 6161 + let headers = response.headers_mut(); 6162 6162 + headers 6163 6163 + .insert( 6164 6164 + tonic::Status::GRPC_STATUS, 6165 6165 + (tonic::Code::Unimplemented as i32).into(), 6166 6166 + ); 6167 6167 + headers 6168 6168 + .insert( 6169 6169 + http::header::CONTENT_TYPE, 6170 6170 + tonic::metadata::GRPC_CONTENT_TYPE, 6171 6171 + ); 6172 6172 + Ok(response) 6173 6173 + }) 6174 6174 + } 5290 6175 } 5291 6176 } 5292 6177 } ··· 5794 6679 dead_code, 5795 6680 missing_docs, 5796 6681 clippy::wildcard_imports, 5797 5797 - clippy::let_unit_value 6682 6682 + clippy::let_unit_value, 5798 6683 )] 5799 5799 - use tonic::codegen::http::Uri; 5800 6684 use tonic::codegen::*; 6685 6685 + use tonic::codegen::http::Uri; 5801 6686 #[derive(Debug, Clone)] 5802 6687 pub struct SettingsServiceClient<T> { 5803 6688 inner: tonic::client::Grpc<T>, ··· 5841 6726 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 5842 6727 >, 5843 6728 >, 5844 5844 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 5845 5845 - Into<StdError> + std::marker::Send + std::marker::Sync, 6729 6729 + <T as tonic::codegen::Service< 6730 6730 + http::Request<tonic::body::BoxBody>, 6731 6731 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 5846 6732 { 5847 6733 SettingsServiceClient::new(InterceptedService::new(inner, interceptor)) 5848 6734 } ··· 5880 6766 pub async fn get_settings_list( 5881 6767 &mut self, 5882 6768 request: impl tonic::IntoRequest<super::GetSettingsListRequest>, 5883 5883 - ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status> 5884 5884 - { 5885 5885 - self.inner.ready().await.map_err(|e| { 5886 5886 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 5887 5887 - })?; 6769 6769 + ) -> std::result::Result< 6770 6770 + tonic::Response<super::GetSettingsListResponse>, 6771 6771 + tonic::Status, 6772 6772 + > { 6773 6773 + self.inner 6774 6774 + .ready() 6775 6775 + .await 6776 6776 + .map_err(|e| { 6777 6777 + tonic::Status::unknown( 6778 6778 + format!("Service was not ready: {}", e.into()), 6779 6779 + ) 6780 6780 + })?; 5888 6781 let codec = tonic::codec::ProstCodec::default(); 5889 6782 let path = http::uri::PathAndQuery::from_static( 5890 6783 "/rockbox.v1alpha1.SettingsService/GetSettingsList", 5891 6784 ); 5892 6785 let mut req = request.into_request(); 5893 5893 - req.extensions_mut().insert(GrpcMethod::new( 5894 5894 - "rockbox.v1alpha1.SettingsService", 5895 5895 - "GetSettingsList", 5896 5896 - )); 6786 6786 + req.extensions_mut() 6787 6787 + .insert( 6788 6788 + GrpcMethod::new( 6789 6789 + "rockbox.v1alpha1.SettingsService", 6790 6790 + "GetSettingsList", 6791 6791 + ), 6792 6792 + ); 5897 6793 self.inner.unary(req, path, codec).await 5898 6794 } 5899 6795 pub async fn get_global_settings( 5900 6796 &mut self, 5901 6797 request: impl tonic::IntoRequest<super::GetGlobalSettingsRequest>, 5902 5902 - ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status> 5903 5903 - { 5904 5904 - self.inner.ready().await.map_err(|e| { 5905 5905 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 5906 5906 - })?; 6798 6798 + ) -> std::result::Result< 6799 6799 + tonic::Response<super::GetGlobalSettingsResponse>, 6800 6800 + tonic::Status, 6801 6801 + > { 6802 6802 + self.inner 6803 6803 + .ready() 6804 6804 + .await 6805 6805 + .map_err(|e| { 6806 6806 + tonic::Status::unknown( 6807 6807 + format!("Service was not ready: {}", e.into()), 6808 6808 + ) 6809 6809 + })?; 5907 6810 let codec = tonic::codec::ProstCodec::default(); 5908 6811 let path = http::uri::PathAndQuery::from_static( 5909 6812 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings", 5910 6813 ); 5911 6814 let mut req = request.into_request(); 5912 5912 - req.extensions_mut().insert(GrpcMethod::new( 5913 5913 - "rockbox.v1alpha1.SettingsService", 5914 5914 - "GetGlobalSettings", 5915 5915 - )); 6815 6815 + req.extensions_mut() 6816 6816 + .insert( 6817 6817 + GrpcMethod::new( 6818 6818 + "rockbox.v1alpha1.SettingsService", 6819 6819 + "GetGlobalSettings", 6820 6820 + ), 6821 6821 + ); 5916 6822 self.inner.unary(req, path, codec).await 5917 6823 } 5918 6824 pub async fn save_settings( 5919 6825 &mut self, 5920 6826 request: impl tonic::IntoRequest<super::SaveSettingsRequest>, 5921 5921 - ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status> 5922 5922 - { 5923 5923 - self.inner.ready().await.map_err(|e| { 5924 5924 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 5925 5925 - })?; 6827 6827 + ) -> std::result::Result< 6828 6828 + tonic::Response<super::SaveSettingsResponse>, 6829 6829 + tonic::Status, 6830 6830 + > { 6831 6831 + self.inner 6832 6832 + .ready() 6833 6833 + .await 6834 6834 + .map_err(|e| { 6835 6835 + tonic::Status::unknown( 6836 6836 + format!("Service was not ready: {}", e.into()), 6837 6837 + ) 6838 6838 + })?; 5926 6839 let codec = tonic::codec::ProstCodec::default(); 5927 6840 let path = http::uri::PathAndQuery::from_static( 5928 6841 "/rockbox.v1alpha1.SettingsService/SaveSettings", 5929 6842 ); 5930 6843 let mut req = request.into_request(); 5931 5931 - req.extensions_mut().insert(GrpcMethod::new( 5932 5932 - "rockbox.v1alpha1.SettingsService", 5933 5933 - "SaveSettings", 5934 5934 - )); 6844 6844 + req.extensions_mut() 6845 6845 + .insert( 6846 6846 + GrpcMethod::new("rockbox.v1alpha1.SettingsService", "SaveSettings"), 6847 6847 + ); 5935 6848 self.inner.unary(req, path, codec).await 5936 6849 } 5937 6850 } ··· 5943 6856 dead_code, 5944 6857 missing_docs, 5945 6858 clippy::wildcard_imports, 5946 5946 - clippy::let_unit_value 6859 6859 + clippy::let_unit_value, 5947 6860 )] 5948 6861 use tonic::codegen::*; 5949 6862 /// Generated trait containing gRPC methods that should be implemented for use with SettingsServiceServer. ··· 5952 6865 async fn get_settings_list( 5953 6866 &self, 5954 6867 request: tonic::Request<super::GetSettingsListRequest>, 5955 5955 - ) -> std::result::Result<tonic::Response<super::GetSettingsListResponse>, tonic::Status>; 6868 6868 + ) -> std::result::Result< 6869 6869 + tonic::Response<super::GetSettingsListResponse>, 6870 6870 + tonic::Status, 6871 6871 + >; 5956 6872 async fn get_global_settings( 5957 6873 &self, 5958 6874 request: tonic::Request<super::GetGlobalSettingsRequest>, 5959 5959 - ) -> std::result::Result<tonic::Response<super::GetGlobalSettingsResponse>, tonic::Status>; 6875 6875 + ) -> std::result::Result< 6876 6876 + tonic::Response<super::GetGlobalSettingsResponse>, 6877 6877 + tonic::Status, 6878 6878 + >; 5960 6879 async fn save_settings( 5961 6880 &self, 5962 6881 request: tonic::Request<super::SaveSettingsRequest>, 5963 5963 - ) -> std::result::Result<tonic::Response<super::SaveSettingsResponse>, tonic::Status>; 6882 6882 + ) -> std::result::Result< 6883 6883 + tonic::Response<super::SaveSettingsResponse>, 6884 6884 + tonic::Status, 6885 6885 + >; 5964 6886 } 5965 6887 #[derive(Debug)] 5966 6888 pub struct SettingsServiceServer<T> { ··· 5983 6905 max_encoding_message_size: None, 5984 6906 } 5985 6907 } 5986 5986 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 6908 6908 + pub fn with_interceptor<F>( 6909 6909 + inner: T, 6910 6910 + interceptor: F, 6911 6911 + ) -> InterceptedService<Self, F> 5987 6912 where 5988 6913 F: tonic::service::Interceptor, 5989 6914 { ··· 6038 6963 "/rockbox.v1alpha1.SettingsService/GetSettingsList" => { 6039 6964 #[allow(non_camel_case_types)] 6040 6965 struct GetSettingsListSvc<T: SettingsService>(pub Arc<T>); 6041 6041 - impl<T: SettingsService> 6042 6042 - tonic::server::UnaryService<super::GetSettingsListRequest> 6043 6043 - for GetSettingsListSvc<T> 6044 6044 - { 6966 6966 + impl< 6967 6967 + T: SettingsService, 6968 6968 + > tonic::server::UnaryService<super::GetSettingsListRequest> 6969 6969 + for GetSettingsListSvc<T> { 6045 6970 type Response = super::GetSettingsListResponse; 6046 6046 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 6971 6971 + type Future = BoxFuture< 6972 6972 + tonic::Response<Self::Response>, 6973 6973 + tonic::Status, 6974 6974 + >; 6047 6975 fn call( 6048 6976 &mut self, 6049 6977 request: tonic::Request<super::GetSettingsListRequest>, 6050 6978 ) -> Self::Future { 6051 6979 let inner = Arc::clone(&self.0); 6052 6980 let fut = async move { 6053 6053 - <T as SettingsService>::get_settings_list(&inner, request).await 6981 6981 + <T as SettingsService>::get_settings_list(&inner, request) 6982 6982 + .await 6054 6983 }; 6055 6984 Box::pin(fut) 6056 6985 } ··· 6080 7009 "/rockbox.v1alpha1.SettingsService/GetGlobalSettings" => { 6081 7010 #[allow(non_camel_case_types)] 6082 7011 struct GetGlobalSettingsSvc<T: SettingsService>(pub Arc<T>); 6083 6083 - impl<T: SettingsService> 6084 6084 - tonic::server::UnaryService<super::GetGlobalSettingsRequest> 6085 6085 - for GetGlobalSettingsSvc<T> 6086 6086 - { 7012 7012 + impl< 7013 7013 + T: SettingsService, 7014 7014 + > tonic::server::UnaryService<super::GetGlobalSettingsRequest> 7015 7015 + for GetGlobalSettingsSvc<T> { 6087 7016 type Response = super::GetGlobalSettingsResponse; 6088 6088 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7017 7017 + type Future = BoxFuture< 7018 7018 + tonic::Response<Self::Response>, 7019 7019 + tonic::Status, 7020 7020 + >; 6089 7021 fn call( 6090 7022 &mut self, 6091 7023 request: tonic::Request<super::GetGlobalSettingsRequest>, 6092 7024 ) -> Self::Future { 6093 7025 let inner = Arc::clone(&self.0); 6094 7026 let fut = async move { 6095 6095 - <T as SettingsService>::get_global_settings(&inner, request).await 7027 7027 + <T as SettingsService>::get_global_settings(&inner, request) 7028 7028 + .await 6096 7029 }; 6097 7030 Box::pin(fut) 6098 7031 } ··· 6122 7055 "/rockbox.v1alpha1.SettingsService/SaveSettings" => { 6123 7056 #[allow(non_camel_case_types)] 6124 7057 struct SaveSettingsSvc<T: SettingsService>(pub Arc<T>); 6125 6125 - impl<T: SettingsService> tonic::server::UnaryService<super::SaveSettingsRequest> 6126 6126 - for SaveSettingsSvc<T> 6127 6127 - { 7058 7058 + impl< 7059 7059 + T: SettingsService, 7060 7060 + > tonic::server::UnaryService<super::SaveSettingsRequest> 7061 7061 + for SaveSettingsSvc<T> { 6128 7062 type Response = super::SaveSettingsResponse; 6129 6129 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7063 7063 + type Future = BoxFuture< 7064 7064 + tonic::Response<Self::Response>, 7065 7065 + tonic::Status, 7066 7066 + >; 6130 7067 fn call( 6131 7068 &mut self, 6132 7069 request: tonic::Request<super::SaveSettingsRequest>, ··· 6160 7097 }; 6161 7098 Box::pin(fut) 6162 7099 } 6163 6163 - _ => Box::pin(async move { 6164 6164 - let mut response = http::Response::new(empty_body()); 6165 6165 - let headers = response.headers_mut(); 6166 6166 - headers.insert( 6167 6167 - tonic::Status::GRPC_STATUS, 6168 6168 - (tonic::Code::Unimplemented as i32).into(), 6169 6169 - ); 6170 6170 - headers.insert( 6171 6171 - http::header::CONTENT_TYPE, 6172 6172 - tonic::metadata::GRPC_CONTENT_TYPE, 6173 6173 - ); 6174 6174 - Ok(response) 6175 6175 - }), 7100 7100 + _ => { 7101 7101 + Box::pin(async move { 7102 7102 + let mut response = http::Response::new(empty_body()); 7103 7103 + let headers = response.headers_mut(); 7104 7104 + headers 7105 7105 + .insert( 7106 7106 + tonic::Status::GRPC_STATUS, 7107 7107 + (tonic::Code::Unimplemented as i32).into(), 7108 7108 + ); 7109 7109 + headers 7110 7110 + .insert( 7111 7111 + http::header::CONTENT_TYPE, 7112 7112 + tonic::metadata::GRPC_CONTENT_TYPE, 7113 7113 + ); 7114 7114 + Ok(response) 7115 7115 + }) 7116 7116 + } 6176 7117 } 6177 7118 } 6178 7119 } ··· 6330 7271 dead_code, 6331 7272 missing_docs, 6332 7273 clippy::wildcard_imports, 6333 6333 - clippy::let_unit_value 7274 7274 + clippy::let_unit_value, 6334 7275 )] 6335 6335 - use tonic::codegen::http::Uri; 6336 7276 use tonic::codegen::*; 7277 7277 + use tonic::codegen::http::Uri; 6337 7278 #[derive(Debug, Clone)] 6338 7279 pub struct SoundServiceClient<T> { 6339 7280 inner: tonic::client::Grpc<T>, ··· 6377 7318 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 6378 7319 >, 6379 7320 >, 6380 6380 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 6381 6381 - Into<StdError> + std::marker::Send + std::marker::Sync, 7321 7321 + <T as tonic::codegen::Service< 7322 7322 + http::Request<tonic::body::BoxBody>, 7323 7323 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 6382 7324 { 6383 7325 SoundServiceClient::new(InterceptedService::new(inner, interceptor)) 6384 7326 } ··· 6416 7358 pub async fn adjust_volume( 6417 7359 &mut self, 6418 7360 request: impl tonic::IntoRequest<super::AdjustVolumeRequest>, 6419 6419 - ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status> 6420 6420 - { 6421 6421 - self.inner.ready().await.map_err(|e| { 6422 6422 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6423 6423 - })?; 7361 7361 + ) -> std::result::Result< 7362 7362 + tonic::Response<super::AdjustVolumeResponse>, 7363 7363 + tonic::Status, 7364 7364 + > { 7365 7365 + self.inner 7366 7366 + .ready() 7367 7367 + .await 7368 7368 + .map_err(|e| { 7369 7369 + tonic::Status::unknown( 7370 7370 + format!("Service was not ready: {}", e.into()), 7371 7371 + ) 7372 7372 + })?; 6424 7373 let codec = tonic::codec::ProstCodec::default(); 6425 6425 - let path = 6426 6426 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/AdjustVolume"); 7374 7374 + let path = http::uri::PathAndQuery::from_static( 7375 7375 + "/rockbox.v1alpha1.SoundService/AdjustVolume", 7376 7376 + ); 6427 7377 let mut req = request.into_request(); 6428 6428 - req.extensions_mut().insert(GrpcMethod::new( 6429 6429 - "rockbox.v1alpha1.SoundService", 6430 6430 - "AdjustVolume", 6431 6431 - )); 7378 7378 + req.extensions_mut() 7379 7379 + .insert( 7380 7380 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "AdjustVolume"), 7381 7381 + ); 6432 7382 self.inner.unary(req, path, codec).await 6433 7383 } 6434 7384 pub async fn sound_set( 6435 7385 &mut self, 6436 7386 request: impl tonic::IntoRequest<super::SoundSetRequest>, 6437 6437 - ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status> { 6438 6438 - self.inner.ready().await.map_err(|e| { 6439 6439 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6440 6440 - })?; 7387 7387 + ) -> std::result::Result< 7388 7388 + tonic::Response<super::SoundSetResponse>, 7389 7389 + tonic::Status, 7390 7390 + > { 7391 7391 + self.inner 7392 7392 + .ready() 7393 7393 + .await 7394 7394 + .map_err(|e| { 7395 7395 + tonic::Status::unknown( 7396 7396 + format!("Service was not ready: {}", e.into()), 7397 7397 + ) 7398 7398 + })?; 6441 7399 let codec = tonic::codec::ProstCodec::default(); 6442 6442 - let path = 6443 6443 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundSet"); 7400 7400 + let path = http::uri::PathAndQuery::from_static( 7401 7401 + "/rockbox.v1alpha1.SoundService/SoundSet", 7402 7402 + ); 6444 7403 let mut req = request.into_request(); 6445 7404 req.extensions_mut() 6446 7405 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundSet")); ··· 6449 7408 pub async fn sound_current( 6450 7409 &mut self, 6451 7410 request: impl tonic::IntoRequest<super::SoundCurrentRequest>, 6452 6452 - ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status> 6453 6453 - { 6454 6454 - self.inner.ready().await.map_err(|e| { 6455 6455 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6456 6456 - })?; 7411 7411 + ) -> std::result::Result< 7412 7412 + tonic::Response<super::SoundCurrentResponse>, 7413 7413 + tonic::Status, 7414 7414 + > { 7415 7415 + self.inner 7416 7416 + .ready() 7417 7417 + .await 7418 7418 + .map_err(|e| { 7419 7419 + tonic::Status::unknown( 7420 7420 + format!("Service was not ready: {}", e.into()), 7421 7421 + ) 7422 7422 + })?; 6457 7423 let codec = tonic::codec::ProstCodec::default(); 6458 6458 - let path = 6459 6459 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundCurrent"); 7424 7424 + let path = http::uri::PathAndQuery::from_static( 7425 7425 + "/rockbox.v1alpha1.SoundService/SoundCurrent", 7426 7426 + ); 6460 7427 let mut req = request.into_request(); 6461 6461 - req.extensions_mut().insert(GrpcMethod::new( 6462 6462 - "rockbox.v1alpha1.SoundService", 6463 6463 - "SoundCurrent", 6464 6464 - )); 7428 7428 + req.extensions_mut() 7429 7429 + .insert( 7430 7430 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundCurrent"), 7431 7431 + ); 6465 7432 self.inner.unary(req, path, codec).await 6466 7433 } 6467 7434 pub async fn sound_default( 6468 7435 &mut self, 6469 7436 request: impl tonic::IntoRequest<super::SoundDefaultRequest>, 6470 6470 - ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status> 6471 6471 - { 6472 6472 - self.inner.ready().await.map_err(|e| { 6473 6473 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6474 6474 - })?; 7437 7437 + ) -> std::result::Result< 7438 7438 + tonic::Response<super::SoundDefaultResponse>, 7439 7439 + tonic::Status, 7440 7440 + > { 7441 7441 + self.inner 7442 7442 + .ready() 7443 7443 + .await 7444 7444 + .map_err(|e| { 7445 7445 + tonic::Status::unknown( 7446 7446 + format!("Service was not ready: {}", e.into()), 7447 7447 + ) 7448 7448 + })?; 6475 7449 let codec = tonic::codec::ProstCodec::default(); 6476 6476 - let path = 6477 6477 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundDefault"); 7450 7450 + let path = http::uri::PathAndQuery::from_static( 7451 7451 + "/rockbox.v1alpha1.SoundService/SoundDefault", 7452 7452 + ); 6478 7453 let mut req = request.into_request(); 6479 6479 - req.extensions_mut().insert(GrpcMethod::new( 6480 6480 - "rockbox.v1alpha1.SoundService", 6481 6481 - "SoundDefault", 6482 6482 - )); 7454 7454 + req.extensions_mut() 7455 7455 + .insert( 7456 7456 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundDefault"), 7457 7457 + ); 6483 7458 self.inner.unary(req, path, codec).await 6484 7459 } 6485 7460 pub async fn sound_min( 6486 7461 &mut self, 6487 7462 request: impl tonic::IntoRequest<super::SoundMinRequest>, 6488 6488 - ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status> { 6489 6489 - self.inner.ready().await.map_err(|e| { 6490 6490 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6491 6491 - })?; 7463 7463 + ) -> std::result::Result< 7464 7464 + tonic::Response<super::SoundMinResponse>, 7465 7465 + tonic::Status, 7466 7466 + > { 7467 7467 + self.inner 7468 7468 + .ready() 7469 7469 + .await 7470 7470 + .map_err(|e| { 7471 7471 + tonic::Status::unknown( 7472 7472 + format!("Service was not ready: {}", e.into()), 7473 7473 + ) 7474 7474 + })?; 6492 7475 let codec = tonic::codec::ProstCodec::default(); 6493 6493 - let path = 6494 6494 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMin"); 7476 7476 + let path = http::uri::PathAndQuery::from_static( 7477 7477 + "/rockbox.v1alpha1.SoundService/SoundMin", 7478 7478 + ); 6495 7479 let mut req = request.into_request(); 6496 7480 req.extensions_mut() 6497 7481 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMin")); ··· 6500 7484 pub async fn sound_max( 6501 7485 &mut self, 6502 7486 request: impl tonic::IntoRequest<super::SoundMaxRequest>, 6503 6503 - ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status> { 6504 6504 - self.inner.ready().await.map_err(|e| { 6505 6505 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6506 6506 - })?; 7487 7487 + ) -> std::result::Result< 7488 7488 + tonic::Response<super::SoundMaxResponse>, 7489 7489 + tonic::Status, 7490 7490 + > { 7491 7491 + self.inner 7492 7492 + .ready() 7493 7493 + .await 7494 7494 + .map_err(|e| { 7495 7495 + tonic::Status::unknown( 7496 7496 + format!("Service was not ready: {}", e.into()), 7497 7497 + ) 7498 7498 + })?; 6507 7499 let codec = tonic::codec::ProstCodec::default(); 6508 6508 - let path = 6509 6509 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundMax"); 7500 7500 + let path = http::uri::PathAndQuery::from_static( 7501 7501 + "/rockbox.v1alpha1.SoundService/SoundMax", 7502 7502 + ); 6510 7503 let mut req = request.into_request(); 6511 7504 req.extensions_mut() 6512 7505 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundMax")); ··· 6515 7508 pub async fn sound_unit( 6516 7509 &mut self, 6517 7510 request: impl tonic::IntoRequest<super::SoundUnitRequest>, 6518 6518 - ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status> { 6519 6519 - self.inner.ready().await.map_err(|e| { 6520 6520 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6521 6521 - })?; 7511 7511 + ) -> std::result::Result< 7512 7512 + tonic::Response<super::SoundUnitResponse>, 7513 7513 + tonic::Status, 7514 7514 + > { 7515 7515 + self.inner 7516 7516 + .ready() 7517 7517 + .await 7518 7518 + .map_err(|e| { 7519 7519 + tonic::Status::unknown( 7520 7520 + format!("Service was not ready: {}", e.into()), 7521 7521 + ) 7522 7522 + })?; 6522 7523 let codec = tonic::codec::ProstCodec::default(); 6523 6523 - let path = 6524 6524 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SoundUnit"); 7524 7524 + let path = http::uri::PathAndQuery::from_static( 7525 7525 + "/rockbox.v1alpha1.SoundService/SoundUnit", 7526 7526 + ); 6525 7527 let mut req = request.into_request(); 6526 6526 - req.extensions_mut().insert(GrpcMethod::new( 6527 6527 - "rockbox.v1alpha1.SoundService", 6528 6528 - "SoundUnit", 6529 6529 - )); 7528 7528 + req.extensions_mut() 7529 7529 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundUnit")); 6530 7530 self.inner.unary(req, path, codec).await 6531 7531 } 6532 7532 pub async fn sound_val2_phys( 6533 7533 &mut self, 6534 7534 request: impl tonic::IntoRequest<super::SoundVal2PhysRequest>, 6535 6535 - ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status> 6536 6536 - { 6537 6537 - self.inner.ready().await.map_err(|e| { 6538 6538 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6539 6539 - })?; 7535 7535 + ) -> std::result::Result< 7536 7536 + tonic::Response<super::SoundVal2PhysResponse>, 7537 7537 + tonic::Status, 7538 7538 + > { 7539 7539 + self.inner 7540 7540 + .ready() 7541 7541 + .await 7542 7542 + .map_err(|e| { 7543 7543 + tonic::Status::unknown( 7544 7544 + format!("Service was not ready: {}", e.into()), 7545 7545 + ) 7546 7546 + })?; 6540 7547 let codec = tonic::codec::ProstCodec::default(); 6541 7548 let path = http::uri::PathAndQuery::from_static( 6542 7549 "/rockbox.v1alpha1.SoundService/SoundVal2Phys", 6543 7550 ); 6544 7551 let mut req = request.into_request(); 6545 6545 - req.extensions_mut().insert(GrpcMethod::new( 6546 6546 - "rockbox.v1alpha1.SoundService", 6547 6547 - "SoundVal2Phys", 6548 6548 - )); 7552 7552 + req.extensions_mut() 7553 7553 + .insert( 7554 7554 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SoundVal2Phys"), 7555 7555 + ); 6549 7556 self.inner.unary(req, path, codec).await 6550 7557 } 6551 7558 pub async fn get_pitch( 6552 7559 &mut self, 6553 7560 request: impl tonic::IntoRequest<super::GetPitchRequest>, 6554 6554 - ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status> { 6555 6555 - self.inner.ready().await.map_err(|e| { 6556 6556 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6557 6557 - })?; 7561 7561 + ) -> std::result::Result< 7562 7562 + tonic::Response<super::GetPitchResponse>, 7563 7563 + tonic::Status, 7564 7564 + > { 7565 7565 + self.inner 7566 7566 + .ready() 7567 7567 + .await 7568 7568 + .map_err(|e| { 7569 7569 + tonic::Status::unknown( 7570 7570 + format!("Service was not ready: {}", e.into()), 7571 7571 + ) 7572 7572 + })?; 6558 7573 let codec = tonic::codec::ProstCodec::default(); 6559 6559 - let path = 6560 6560 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/GetPitch"); 7574 7574 + let path = http::uri::PathAndQuery::from_static( 7575 7575 + "/rockbox.v1alpha1.SoundService/GetPitch", 7576 7576 + ); 6561 7577 let mut req = request.into_request(); 6562 7578 req.extensions_mut() 6563 7579 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "GetPitch")); ··· 6566 7582 pub async fn set_pitch( 6567 7583 &mut self, 6568 7584 request: impl tonic::IntoRequest<super::SetPitchRequest>, 6569 6569 - ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status> { 6570 6570 - self.inner.ready().await.map_err(|e| { 6571 6571 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6572 6572 - })?; 7585 7585 + ) -> std::result::Result< 7586 7586 + tonic::Response<super::SetPitchResponse>, 7587 7587 + tonic::Status, 7588 7588 + > { 7589 7589 + self.inner 7590 7590 + .ready() 7591 7591 + .await 7592 7592 + .map_err(|e| { 7593 7593 + tonic::Status::unknown( 7594 7594 + format!("Service was not ready: {}", e.into()), 7595 7595 + ) 7596 7596 + })?; 6573 7597 let codec = tonic::codec::ProstCodec::default(); 6574 6574 - let path = 6575 6575 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/SetPitch"); 7598 7598 + let path = http::uri::PathAndQuery::from_static( 7599 7599 + "/rockbox.v1alpha1.SoundService/SetPitch", 7600 7600 + ); 6576 7601 let mut req = request.into_request(); 6577 7602 req.extensions_mut() 6578 7603 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "SetPitch")); ··· 6581 7606 pub async fn beep_play( 6582 7607 &mut self, 6583 7608 request: impl tonic::IntoRequest<super::BeepPlayRequest>, 6584 6584 - ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status> { 6585 6585 - self.inner.ready().await.map_err(|e| { 6586 6586 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6587 6587 - })?; 7609 7609 + ) -> std::result::Result< 7610 7610 + tonic::Response<super::BeepPlayResponse>, 7611 7611 + tonic::Status, 7612 7612 + > { 7613 7613 + self.inner 7614 7614 + .ready() 7615 7615 + .await 7616 7616 + .map_err(|e| { 7617 7617 + tonic::Status::unknown( 7618 7618 + format!("Service was not ready: {}", e.into()), 7619 7619 + ) 7620 7620 + })?; 6588 7621 let codec = tonic::codec::ProstCodec::default(); 6589 6589 - let path = 6590 6590 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/BeepPlay"); 7622 7622 + let path = http::uri::PathAndQuery::from_static( 7623 7623 + "/rockbox.v1alpha1.SoundService/BeepPlay", 7624 7624 + ); 6591 7625 let mut req = request.into_request(); 6592 7626 req.extensions_mut() 6593 7627 .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "BeepPlay")); ··· 6596 7630 pub async fn pcmbuf_fade( 6597 7631 &mut self, 6598 7632 request: impl tonic::IntoRequest<super::PcmbufFadeRequest>, 6599 6599 - ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status> 6600 6600 - { 6601 6601 - self.inner.ready().await.map_err(|e| { 6602 6602 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6603 6603 - })?; 7633 7633 + ) -> std::result::Result< 7634 7634 + tonic::Response<super::PcmbufFadeResponse>, 7635 7635 + tonic::Status, 7636 7636 + > { 7637 7637 + self.inner 7638 7638 + .ready() 7639 7639 + .await 7640 7640 + .map_err(|e| { 7641 7641 + tonic::Status::unknown( 7642 7642 + format!("Service was not ready: {}", e.into()), 7643 7643 + ) 7644 7644 + })?; 6604 7645 let codec = tonic::codec::ProstCodec::default(); 6605 6605 - let path = 6606 6606 - http::uri::PathAndQuery::from_static("/rockbox.v1alpha1.SoundService/PcmbufFade"); 7646 7646 + let path = http::uri::PathAndQuery::from_static( 7647 7647 + "/rockbox.v1alpha1.SoundService/PcmbufFade", 7648 7648 + ); 6607 7649 let mut req = request.into_request(); 6608 6608 - req.extensions_mut().insert(GrpcMethod::new( 6609 6609 - "rockbox.v1alpha1.SoundService", 6610 6610 - "PcmbufFade", 6611 6611 - )); 7650 7650 + req.extensions_mut() 7651 7651 + .insert(GrpcMethod::new("rockbox.v1alpha1.SoundService", "PcmbufFade")); 6612 7652 self.inner.unary(req, path, codec).await 6613 7653 } 6614 7654 pub async fn pcmbuf_set_low_latency( 6615 7655 &mut self, 6616 7656 request: impl tonic::IntoRequest<super::PcmbufSetLowLatencyRequest>, 6617 6617 - ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status> 6618 6618 - { 6619 6619 - self.inner.ready().await.map_err(|e| { 6620 6620 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6621 6621 - })?; 7657 7657 + ) -> std::result::Result< 7658 7658 + tonic::Response<super::PcmbufSetLowLatencyResponse>, 7659 7659 + tonic::Status, 7660 7660 + > { 7661 7661 + self.inner 7662 7662 + .ready() 7663 7663 + .await 7664 7664 + .map_err(|e| { 7665 7665 + tonic::Status::unknown( 7666 7666 + format!("Service was not ready: {}", e.into()), 7667 7667 + ) 7668 7668 + })?; 6622 7669 let codec = tonic::codec::ProstCodec::default(); 6623 7670 let path = http::uri::PathAndQuery::from_static( 6624 7671 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency", 6625 7672 ); 6626 7673 let mut req = request.into_request(); 6627 6627 - req.extensions_mut().insert(GrpcMethod::new( 6628 6628 - "rockbox.v1alpha1.SoundService", 6629 6629 - "PcmbufSetLowLatency", 6630 6630 - )); 7674 7674 + req.extensions_mut() 7675 7675 + .insert( 7676 7676 + GrpcMethod::new( 7677 7677 + "rockbox.v1alpha1.SoundService", 7678 7678 + "PcmbufSetLowLatency", 7679 7679 + ), 7680 7680 + ); 6631 7681 self.inner.unary(req, path, codec).await 6632 7682 } 6633 7683 pub async fn system_sound_play( 6634 7684 &mut self, 6635 7685 request: impl tonic::IntoRequest<super::SystemSoundPlayRequest>, 6636 6636 - ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status> 6637 6637 - { 6638 6638 - self.inner.ready().await.map_err(|e| { 6639 6639 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6640 6640 - })?; 7686 7686 + ) -> std::result::Result< 7687 7687 + tonic::Response<super::SystemSoundPlayResponse>, 7688 7688 + tonic::Status, 7689 7689 + > { 7690 7690 + self.inner 7691 7691 + .ready() 7692 7692 + .await 7693 7693 + .map_err(|e| { 7694 7694 + tonic::Status::unknown( 7695 7695 + format!("Service was not ready: {}", e.into()), 7696 7696 + ) 7697 7697 + })?; 6641 7698 let codec = tonic::codec::ProstCodec::default(); 6642 7699 let path = http::uri::PathAndQuery::from_static( 6643 7700 "/rockbox.v1alpha1.SoundService/SystemSoundPlay", 6644 7701 ); 6645 7702 let mut req = request.into_request(); 6646 6646 - req.extensions_mut().insert(GrpcMethod::new( 6647 6647 - "rockbox.v1alpha1.SoundService", 6648 6648 - "SystemSoundPlay", 6649 6649 - )); 7703 7703 + req.extensions_mut() 7704 7704 + .insert( 7705 7705 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "SystemSoundPlay"), 7706 7706 + ); 6650 7707 self.inner.unary(req, path, codec).await 6651 7708 } 6652 7709 pub async fn keyclick_click( 6653 7710 &mut self, 6654 7711 request: impl tonic::IntoRequest<super::KeyclickClickRequest>, 6655 6655 - ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status> 6656 6656 - { 6657 6657 - self.inner.ready().await.map_err(|e| { 6658 6658 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 6659 6659 - })?; 7712 7712 + ) -> std::result::Result< 7713 7713 + tonic::Response<super::KeyclickClickResponse>, 7714 7714 + tonic::Status, 7715 7715 + > { 7716 7716 + self.inner 7717 7717 + .ready() 7718 7718 + .await 7719 7719 + .map_err(|e| { 7720 7720 + tonic::Status::unknown( 7721 7721 + format!("Service was not ready: {}", e.into()), 7722 7722 + ) 7723 7723 + })?; 6660 7724 let codec = tonic::codec::ProstCodec::default(); 6661 7725 let path = http::uri::PathAndQuery::from_static( 6662 7726 "/rockbox.v1alpha1.SoundService/KeyclickClick", 6663 7727 ); 6664 7728 let mut req = request.into_request(); 6665 6665 - req.extensions_mut().insert(GrpcMethod::new( 6666 6666 - "rockbox.v1alpha1.SoundService", 6667 6667 - "KeyclickClick", 6668 6668 - )); 7729 7729 + req.extensions_mut() 7730 7730 + .insert( 7731 7731 + GrpcMethod::new("rockbox.v1alpha1.SoundService", "KeyclickClick"), 7732 7732 + ); 6669 7733 self.inner.unary(req, path, codec).await 6670 7734 } 6671 7735 } ··· 6677 7741 dead_code, 6678 7742 missing_docs, 6679 7743 clippy::wildcard_imports, 6680 6680 - clippy::let_unit_value 7744 7744 + clippy::let_unit_value, 6681 7745 )] 6682 7746 use tonic::codegen::*; 6683 7747 /// Generated trait containing gRPC methods that should be implemented for use with SoundServiceServer. ··· 6686 7750 async fn adjust_volume( 6687 7751 &self, 6688 7752 request: tonic::Request<super::AdjustVolumeRequest>, 6689 6689 - ) -> std::result::Result<tonic::Response<super::AdjustVolumeResponse>, tonic::Status>; 7753 7753 + ) -> std::result::Result< 7754 7754 + tonic::Response<super::AdjustVolumeResponse>, 7755 7755 + tonic::Status, 7756 7756 + >; 6690 7757 async fn sound_set( 6691 7758 &self, 6692 7759 request: tonic::Request<super::SoundSetRequest>, 6693 6693 - ) -> std::result::Result<tonic::Response<super::SoundSetResponse>, tonic::Status>; 7760 7760 + ) -> std::result::Result< 7761 7761 + tonic::Response<super::SoundSetResponse>, 7762 7762 + tonic::Status, 7763 7763 + >; 6694 7764 async fn sound_current( 6695 7765 &self, 6696 7766 request: tonic::Request<super::SoundCurrentRequest>, 6697 6697 - ) -> std::result::Result<tonic::Response<super::SoundCurrentResponse>, tonic::Status>; 7767 7767 + ) -> std::result::Result< 7768 7768 + tonic::Response<super::SoundCurrentResponse>, 7769 7769 + tonic::Status, 7770 7770 + >; 6698 7771 async fn sound_default( 6699 7772 &self, 6700 7773 request: tonic::Request<super::SoundDefaultRequest>, 6701 6701 - ) -> std::result::Result<tonic::Response<super::SoundDefaultResponse>, tonic::Status>; 7774 7774 + ) -> std::result::Result< 7775 7775 + tonic::Response<super::SoundDefaultResponse>, 7776 7776 + tonic::Status, 7777 7777 + >; 6702 7778 async fn sound_min( 6703 7779 &self, 6704 7780 request: tonic::Request<super::SoundMinRequest>, 6705 6705 - ) -> std::result::Result<tonic::Response<super::SoundMinResponse>, tonic::Status>; 7781 7781 + ) -> std::result::Result< 7782 7782 + tonic::Response<super::SoundMinResponse>, 7783 7783 + tonic::Status, 7784 7784 + >; 6706 7785 async fn sound_max( 6707 7786 &self, 6708 7787 request: tonic::Request<super::SoundMaxRequest>, 6709 6709 - ) -> std::result::Result<tonic::Response<super::SoundMaxResponse>, tonic::Status>; 7788 7788 + ) -> std::result::Result< 7789 7789 + tonic::Response<super::SoundMaxResponse>, 7790 7790 + tonic::Status, 7791 7791 + >; 6710 7792 async fn sound_unit( 6711 7793 &self, 6712 7794 request: tonic::Request<super::SoundUnitRequest>, 6713 6713 - ) -> std::result::Result<tonic::Response<super::SoundUnitResponse>, tonic::Status>; 7795 7795 + ) -> std::result::Result< 7796 7796 + tonic::Response<super::SoundUnitResponse>, 7797 7797 + tonic::Status, 7798 7798 + >; 6714 7799 async fn sound_val2_phys( 6715 7800 &self, 6716 7801 request: tonic::Request<super::SoundVal2PhysRequest>, 6717 6717 - ) -> std::result::Result<tonic::Response<super::SoundVal2PhysResponse>, tonic::Status>; 7802 7802 + ) -> std::result::Result< 7803 7803 + tonic::Response<super::SoundVal2PhysResponse>, 7804 7804 + tonic::Status, 7805 7805 + >; 6718 7806 async fn get_pitch( 6719 7807 &self, 6720 7808 request: tonic::Request<super::GetPitchRequest>, 6721 6721 - ) -> std::result::Result<tonic::Response<super::GetPitchResponse>, tonic::Status>; 7809 7809 + ) -> std::result::Result< 7810 7810 + tonic::Response<super::GetPitchResponse>, 7811 7811 + tonic::Status, 7812 7812 + >; 6722 7813 async fn set_pitch( 6723 7814 &self, 6724 7815 request: tonic::Request<super::SetPitchRequest>, 6725 6725 - ) -> std::result::Result<tonic::Response<super::SetPitchResponse>, tonic::Status>; 7816 7816 + ) -> std::result::Result< 7817 7817 + tonic::Response<super::SetPitchResponse>, 7818 7818 + tonic::Status, 7819 7819 + >; 6726 7820 async fn beep_play( 6727 7821 &self, 6728 7822 request: tonic::Request<super::BeepPlayRequest>, 6729 6729 - ) -> std::result::Result<tonic::Response<super::BeepPlayResponse>, tonic::Status>; 7823 7823 + ) -> std::result::Result< 7824 7824 + tonic::Response<super::BeepPlayResponse>, 7825 7825 + tonic::Status, 7826 7826 + >; 6730 7827 async fn pcmbuf_fade( 6731 7828 &self, 6732 7829 request: tonic::Request<super::PcmbufFadeRequest>, 6733 6733 - ) -> std::result::Result<tonic::Response<super::PcmbufFadeResponse>, tonic::Status>; 7830 7830 + ) -> std::result::Result< 7831 7831 + tonic::Response<super::PcmbufFadeResponse>, 7832 7832 + tonic::Status, 7833 7833 + >; 6734 7834 async fn pcmbuf_set_low_latency( 6735 7835 &self, 6736 7836 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 6737 6737 - ) -> std::result::Result<tonic::Response<super::PcmbufSetLowLatencyResponse>, tonic::Status>; 7837 7837 + ) -> std::result::Result< 7838 7838 + tonic::Response<super::PcmbufSetLowLatencyResponse>, 7839 7839 + tonic::Status, 7840 7840 + >; 6738 7841 async fn system_sound_play( 6739 7842 &self, 6740 7843 request: tonic::Request<super::SystemSoundPlayRequest>, 6741 6741 - ) -> std::result::Result<tonic::Response<super::SystemSoundPlayResponse>, tonic::Status>; 7844 7844 + ) -> std::result::Result< 7845 7845 + tonic::Response<super::SystemSoundPlayResponse>, 7846 7846 + tonic::Status, 7847 7847 + >; 6742 7848 async fn keyclick_click( 6743 7849 &self, 6744 7850 request: tonic::Request<super::KeyclickClickRequest>, 6745 6745 - ) -> std::result::Result<tonic::Response<super::KeyclickClickResponse>, tonic::Status>; 7851 7851 + ) -> std::result::Result< 7852 7852 + tonic::Response<super::KeyclickClickResponse>, 7853 7853 + tonic::Status, 7854 7854 + >; 6746 7855 } 6747 7856 #[derive(Debug)] 6748 7857 pub struct SoundServiceServer<T> { ··· 6765 7874 max_encoding_message_size: None, 6766 7875 } 6767 7876 } 6768 6768 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 7877 7877 + pub fn with_interceptor<F>( 7878 7878 + inner: T, 7879 7879 + interceptor: F, 7880 7880 + ) -> InterceptedService<Self, F> 6769 7881 where 6770 7882 F: tonic::service::Interceptor, 6771 7883 { ··· 6820 7932 "/rockbox.v1alpha1.SoundService/AdjustVolume" => { 6821 7933 #[allow(non_camel_case_types)] 6822 7934 struct AdjustVolumeSvc<T: SoundService>(pub Arc<T>); 6823 6823 - impl<T: SoundService> tonic::server::UnaryService<super::AdjustVolumeRequest> 6824 6824 - for AdjustVolumeSvc<T> 6825 6825 - { 7935 7935 + impl< 7936 7936 + T: SoundService, 7937 7937 + > tonic::server::UnaryService<super::AdjustVolumeRequest> 7938 7938 + for AdjustVolumeSvc<T> { 6826 7939 type Response = super::AdjustVolumeResponse; 6827 6827 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7940 7940 + type Future = BoxFuture< 7941 7941 + tonic::Response<Self::Response>, 7942 7942 + tonic::Status, 7943 7943 + >; 6828 7944 fn call( 6829 7945 &mut self, 6830 7946 request: tonic::Request<super::AdjustVolumeRequest>, ··· 6861 7977 "/rockbox.v1alpha1.SoundService/SoundSet" => { 6862 7978 #[allow(non_camel_case_types)] 6863 7979 struct SoundSetSvc<T: SoundService>(pub Arc<T>); 6864 6864 - impl<T: SoundService> tonic::server::UnaryService<super::SoundSetRequest> for SoundSetSvc<T> { 7980 7980 + impl< 7981 7981 + T: SoundService, 7982 7982 + > tonic::server::UnaryService<super::SoundSetRequest> 7983 7983 + for SoundSetSvc<T> { 6865 7984 type Response = super::SoundSetResponse; 6866 6866 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 7985 7985 + type Future = BoxFuture< 7986 7986 + tonic::Response<Self::Response>, 7987 7987 + tonic::Status, 7988 7988 + >; 6867 7989 fn call( 6868 7990 &mut self, 6869 7991 request: tonic::Request<super::SoundSetRequest>, ··· 6900 8022 "/rockbox.v1alpha1.SoundService/SoundCurrent" => { 6901 8023 #[allow(non_camel_case_types)] 6902 8024 struct SoundCurrentSvc<T: SoundService>(pub Arc<T>); 6903 6903 - impl<T: SoundService> tonic::server::UnaryService<super::SoundCurrentRequest> 6904 6904 - for SoundCurrentSvc<T> 6905 6905 - { 8025 8025 + impl< 8026 8026 + T: SoundService, 8027 8027 + > tonic::server::UnaryService<super::SoundCurrentRequest> 8028 8028 + for SoundCurrentSvc<T> { 6906 8029 type Response = super::SoundCurrentResponse; 6907 6907 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8030 8030 + type Future = BoxFuture< 8031 8031 + tonic::Response<Self::Response>, 8032 8032 + tonic::Status, 8033 8033 + >; 6908 8034 fn call( 6909 8035 &mut self, 6910 8036 request: tonic::Request<super::SoundCurrentRequest>, ··· 6941 8067 "/rockbox.v1alpha1.SoundService/SoundDefault" => { 6942 8068 #[allow(non_camel_case_types)] 6943 8069 struct SoundDefaultSvc<T: SoundService>(pub Arc<T>); 6944 6944 - impl<T: SoundService> tonic::server::UnaryService<super::SoundDefaultRequest> 6945 6945 - for SoundDefaultSvc<T> 6946 6946 - { 8070 8070 + impl< 8071 8071 + T: SoundService, 8072 8072 + > tonic::server::UnaryService<super::SoundDefaultRequest> 8073 8073 + for SoundDefaultSvc<T> { 6947 8074 type Response = super::SoundDefaultResponse; 6948 6948 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8075 8075 + type Future = BoxFuture< 8076 8076 + tonic::Response<Self::Response>, 8077 8077 + tonic::Status, 8078 8078 + >; 6949 8079 fn call( 6950 8080 &mut self, 6951 8081 request: tonic::Request<super::SoundDefaultRequest>, ··· 6982 8112 "/rockbox.v1alpha1.SoundService/SoundMin" => { 6983 8113 #[allow(non_camel_case_types)] 6984 8114 struct SoundMinSvc<T: SoundService>(pub Arc<T>); 6985 6985 - impl<T: SoundService> tonic::server::UnaryService<super::SoundMinRequest> for SoundMinSvc<T> { 8115 8115 + impl< 8116 8116 + T: SoundService, 8117 8117 + > tonic::server::UnaryService<super::SoundMinRequest> 8118 8118 + for SoundMinSvc<T> { 6986 8119 type Response = super::SoundMinResponse; 6987 6987 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8120 8120 + type Future = BoxFuture< 8121 8121 + tonic::Response<Self::Response>, 8122 8122 + tonic::Status, 8123 8123 + >; 6988 8124 fn call( 6989 8125 &mut self, 6990 8126 request: tonic::Request<super::SoundMinRequest>, ··· 7021 8157 "/rockbox.v1alpha1.SoundService/SoundMax" => { 7022 8158 #[allow(non_camel_case_types)] 7023 8159 struct SoundMaxSvc<T: SoundService>(pub Arc<T>); 7024 7024 - impl<T: SoundService> tonic::server::UnaryService<super::SoundMaxRequest> for SoundMaxSvc<T> { 8160 8160 + impl< 8161 8161 + T: SoundService, 8162 8162 + > tonic::server::UnaryService<super::SoundMaxRequest> 8163 8163 + for SoundMaxSvc<T> { 7025 8164 type Response = super::SoundMaxResponse; 7026 7026 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8165 8165 + type Future = BoxFuture< 8166 8166 + tonic::Response<Self::Response>, 8167 8167 + tonic::Status, 8168 8168 + >; 7027 8169 fn call( 7028 8170 &mut self, 7029 8171 request: tonic::Request<super::SoundMaxRequest>, ··· 7060 8202 "/rockbox.v1alpha1.SoundService/SoundUnit" => { 7061 8203 #[allow(non_camel_case_types)] 7062 8204 struct SoundUnitSvc<T: SoundService>(pub Arc<T>); 7063 7063 - impl<T: SoundService> tonic::server::UnaryService<super::SoundUnitRequest> for SoundUnitSvc<T> { 8205 8205 + impl< 8206 8206 + T: SoundService, 8207 8207 + > tonic::server::UnaryService<super::SoundUnitRequest> 8208 8208 + for SoundUnitSvc<T> { 7064 8209 type Response = super::SoundUnitResponse; 7065 7065 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8210 8210 + type Future = BoxFuture< 8211 8211 + tonic::Response<Self::Response>, 8212 8212 + tonic::Status, 8213 8213 + >; 7066 8214 fn call( 7067 8215 &mut self, 7068 8216 request: tonic::Request<super::SoundUnitRequest>, ··· 7099 8247 "/rockbox.v1alpha1.SoundService/SoundVal2Phys" => { 7100 8248 #[allow(non_camel_case_types)] 7101 8249 struct SoundVal2PhysSvc<T: SoundService>(pub Arc<T>); 7102 7102 - impl<T: SoundService> tonic::server::UnaryService<super::SoundVal2PhysRequest> 7103 7103 - for SoundVal2PhysSvc<T> 7104 7104 - { 8250 8250 + impl< 8251 8251 + T: SoundService, 8252 8252 + > tonic::server::UnaryService<super::SoundVal2PhysRequest> 8253 8253 + for SoundVal2PhysSvc<T> { 7105 8254 type Response = super::SoundVal2PhysResponse; 7106 7106 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8255 8255 + type Future = BoxFuture< 8256 8256 + tonic::Response<Self::Response>, 8257 8257 + tonic::Status, 8258 8258 + >; 7107 8259 fn call( 7108 8260 &mut self, 7109 8261 request: tonic::Request<super::SoundVal2PhysRequest>, ··· 7140 8292 "/rockbox.v1alpha1.SoundService/GetPitch" => { 7141 8293 #[allow(non_camel_case_types)] 7142 8294 struct GetPitchSvc<T: SoundService>(pub Arc<T>); 7143 7143 - impl<T: SoundService> tonic::server::UnaryService<super::GetPitchRequest> for GetPitchSvc<T> { 8295 8295 + impl< 8296 8296 + T: SoundService, 8297 8297 + > tonic::server::UnaryService<super::GetPitchRequest> 8298 8298 + for GetPitchSvc<T> { 7144 8299 type Response = super::GetPitchResponse; 7145 7145 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8300 8300 + type Future = BoxFuture< 8301 8301 + tonic::Response<Self::Response>, 8302 8302 + tonic::Status, 8303 8303 + >; 7146 8304 fn call( 7147 8305 &mut self, 7148 8306 request: tonic::Request<super::GetPitchRequest>, ··· 7179 8337 "/rockbox.v1alpha1.SoundService/SetPitch" => { 7180 8338 #[allow(non_camel_case_types)] 7181 8339 struct SetPitchSvc<T: SoundService>(pub Arc<T>); 7182 7182 - impl<T: SoundService> tonic::server::UnaryService<super::SetPitchRequest> for SetPitchSvc<T> { 8340 8340 + impl< 8341 8341 + T: SoundService, 8342 8342 + > tonic::server::UnaryService<super::SetPitchRequest> 8343 8343 + for SetPitchSvc<T> { 7183 8344 type Response = super::SetPitchResponse; 7184 7184 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8345 8345 + type Future = BoxFuture< 8346 8346 + tonic::Response<Self::Response>, 8347 8347 + tonic::Status, 8348 8348 + >; 7185 8349 fn call( 7186 8350 &mut self, 7187 8351 request: tonic::Request<super::SetPitchRequest>, ··· 7218 8382 "/rockbox.v1alpha1.SoundService/BeepPlay" => { 7219 8383 #[allow(non_camel_case_types)] 7220 8384 struct BeepPlaySvc<T: SoundService>(pub Arc<T>); 7221 7221 - impl<T: SoundService> tonic::server::UnaryService<super::BeepPlayRequest> for BeepPlaySvc<T> { 8385 8385 + impl< 8386 8386 + T: SoundService, 8387 8387 + > tonic::server::UnaryService<super::BeepPlayRequest> 8388 8388 + for BeepPlaySvc<T> { 7222 8389 type Response = super::BeepPlayResponse; 7223 7223 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8390 8390 + type Future = BoxFuture< 8391 8391 + tonic::Response<Self::Response>, 8392 8392 + tonic::Status, 8393 8393 + >; 7224 8394 fn call( 7225 8395 &mut self, 7226 8396 request: tonic::Request<super::BeepPlayRequest>, ··· 7257 8427 "/rockbox.v1alpha1.SoundService/PcmbufFade" => { 7258 8428 #[allow(non_camel_case_types)] 7259 8429 struct PcmbufFadeSvc<T: SoundService>(pub Arc<T>); 7260 7260 - impl<T: SoundService> tonic::server::UnaryService<super::PcmbufFadeRequest> for PcmbufFadeSvc<T> { 8430 8430 + impl< 8431 8431 + T: SoundService, 8432 8432 + > tonic::server::UnaryService<super::PcmbufFadeRequest> 8433 8433 + for PcmbufFadeSvc<T> { 7261 8434 type Response = super::PcmbufFadeResponse; 7262 7262 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8435 8435 + type Future = BoxFuture< 8436 8436 + tonic::Response<Self::Response>, 8437 8437 + tonic::Status, 8438 8438 + >; 7263 8439 fn call( 7264 8440 &mut self, 7265 8441 request: tonic::Request<super::PcmbufFadeRequest>, ··· 7296 8472 "/rockbox.v1alpha1.SoundService/PcmbufSetLowLatency" => { 7297 8473 #[allow(non_camel_case_types)] 7298 8474 struct PcmbufSetLowLatencySvc<T: SoundService>(pub Arc<T>); 7299 7299 - impl<T: SoundService> 7300 7300 - tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 7301 7301 - for PcmbufSetLowLatencySvc<T> 7302 7302 - { 8475 8475 + impl< 8476 8476 + T: SoundService, 8477 8477 + > tonic::server::UnaryService<super::PcmbufSetLowLatencyRequest> 8478 8478 + for PcmbufSetLowLatencySvc<T> { 7303 8479 type Response = super::PcmbufSetLowLatencyResponse; 7304 7304 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8480 8480 + type Future = BoxFuture< 8481 8481 + tonic::Response<Self::Response>, 8482 8482 + tonic::Status, 8483 8483 + >; 7305 8484 fn call( 7306 8485 &mut self, 7307 8486 request: tonic::Request<super::PcmbufSetLowLatencyRequest>, 7308 8487 ) -> Self::Future { 7309 8488 let inner = Arc::clone(&self.0); 7310 8489 let fut = async move { 7311 7311 - <T as SoundService>::pcmbuf_set_low_latency(&inner, request).await 8490 8490 + <T as SoundService>::pcmbuf_set_low_latency(&inner, request) 8491 8491 + .await 7312 8492 }; 7313 8493 Box::pin(fut) 7314 8494 } ··· 7338 8518 "/rockbox.v1alpha1.SoundService/SystemSoundPlay" => { 7339 8519 #[allow(non_camel_case_types)] 7340 8520 struct SystemSoundPlaySvc<T: SoundService>(pub Arc<T>); 7341 7341 - impl<T: SoundService> tonic::server::UnaryService<super::SystemSoundPlayRequest> 7342 7342 - for SystemSoundPlaySvc<T> 7343 7343 - { 8521 8521 + impl< 8522 8522 + T: SoundService, 8523 8523 + > tonic::server::UnaryService<super::SystemSoundPlayRequest> 8524 8524 + for SystemSoundPlaySvc<T> { 7344 8525 type Response = super::SystemSoundPlayResponse; 7345 7345 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8526 8526 + type Future = BoxFuture< 8527 8527 + tonic::Response<Self::Response>, 8528 8528 + tonic::Status, 8529 8529 + >; 7346 8530 fn call( 7347 8531 &mut self, 7348 8532 request: tonic::Request<super::SystemSoundPlayRequest>, 7349 8533 ) -> Self::Future { 7350 8534 let inner = Arc::clone(&self.0); 7351 8535 let fut = async move { 7352 7352 - <T as SoundService>::system_sound_play(&inner, request).await 8536 8536 + <T as SoundService>::system_sound_play(&inner, request) 8537 8537 + .await 7353 8538 }; 7354 8539 Box::pin(fut) 7355 8540 } ··· 7379 8564 "/rockbox.v1alpha1.SoundService/KeyclickClick" => { 7380 8565 #[allow(non_camel_case_types)] 7381 8566 struct KeyclickClickSvc<T: SoundService>(pub Arc<T>); 7382 7382 - impl<T: SoundService> tonic::server::UnaryService<super::KeyclickClickRequest> 7383 7383 - for KeyclickClickSvc<T> 7384 7384 - { 8567 8567 + impl< 8568 8568 + T: SoundService, 8569 8569 + > tonic::server::UnaryService<super::KeyclickClickRequest> 8570 8570 + for KeyclickClickSvc<T> { 7385 8571 type Response = super::KeyclickClickResponse; 7386 7386 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8572 8572 + type Future = BoxFuture< 8573 8573 + tonic::Response<Self::Response>, 8574 8574 + tonic::Status, 8575 8575 + >; 7387 8576 fn call( 7388 8577 &mut self, 7389 8578 request: tonic::Request<super::KeyclickClickRequest>, ··· 7417 8606 }; 7418 8607 Box::pin(fut) 7419 8608 } 7420 7420 - _ => Box::pin(async move { 7421 7421 - let mut response = http::Response::new(empty_body()); 7422 7422 - let headers = response.headers_mut(); 7423 7423 - headers.insert( 7424 7424 - tonic::Status::GRPC_STATUS, 7425 7425 - (tonic::Code::Unimplemented as i32).into(), 7426 7426 - ); 7427 7427 - headers.insert( 7428 7428 - http::header::CONTENT_TYPE, 7429 7429 - tonic::metadata::GRPC_CONTENT_TYPE, 7430 7430 - ); 7431 7431 - Ok(response) 7432 7432 - }), 8609 8609 + _ => { 8610 8610 + Box::pin(async move { 8611 8611 + let mut response = http::Response::new(empty_body()); 8612 8612 + let headers = response.headers_mut(); 8613 8613 + headers 8614 8614 + .insert( 8615 8615 + tonic::Status::GRPC_STATUS, 8616 8616 + (tonic::Code::Unimplemented as i32).into(), 8617 8617 + ); 8618 8618 + headers 8619 8619 + .insert( 8620 8620 + http::header::CONTENT_TYPE, 8621 8621 + tonic::metadata::GRPC_CONTENT_TYPE, 8622 8622 + ); 8623 8623 + Ok(response) 8624 8624 + }) 8625 8625 + } 7433 8626 } 7434 8627 } 7435 8628 } ··· 7490 8683 dead_code, 7491 8684 missing_docs, 7492 8685 clippy::wildcard_imports, 7493 7493 - clippy::let_unit_value 8686 8686 + clippy::let_unit_value, 7494 8687 )] 7495 7495 - use tonic::codegen::http::Uri; 7496 8688 use tonic::codegen::*; 8689 8689 + use tonic::codegen::http::Uri; 7497 8690 #[derive(Debug, Clone)] 7498 8691 pub struct SystemServiceClient<T> { 7499 8692 inner: tonic::client::Grpc<T>, ··· 7537 8730 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 7538 8731 >, 7539 8732 >, 7540 7540 - <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 7541 7541 - Into<StdError> + std::marker::Send + std::marker::Sync, 8733 8733 + <T as tonic::codegen::Service< 8734 8734 + http::Request<tonic::body::BoxBody>, 8735 8735 + >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 7542 8736 { 7543 8737 SystemServiceClient::new(InterceptedService::new(inner, interceptor)) 7544 8738 } ··· 7576 8770 pub async fn get_rockbox_version( 7577 8771 &mut self, 7578 8772 request: impl tonic::IntoRequest<super::GetRockboxVersionRequest>, 7579 7579 - ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status> 7580 7580 - { 7581 7581 - self.inner.ready().await.map_err(|e| { 7582 7582 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7583 7583 - })?; 8773 8773 + ) -> std::result::Result< 8774 8774 + tonic::Response<super::GetRockboxVersionResponse>, 8775 8775 + tonic::Status, 8776 8776 + > { 8777 8777 + self.inner 8778 8778 + .ready() 8779 8779 + .await 8780 8780 + .map_err(|e| { 8781 8781 + tonic::Status::unknown( 8782 8782 + format!("Service was not ready: {}", e.into()), 8783 8783 + ) 8784 8784 + })?; 7584 8785 let codec = tonic::codec::ProstCodec::default(); 7585 8786 let path = http::uri::PathAndQuery::from_static( 7586 8787 "/rockbox.v1alpha1.SystemService/GetRockboxVersion", 7587 8788 ); 7588 8789 let mut req = request.into_request(); 7589 7589 - req.extensions_mut().insert(GrpcMethod::new( 7590 7590 - "rockbox.v1alpha1.SystemService", 7591 7591 - "GetRockboxVersion", 7592 7592 - )); 8790 8790 + req.extensions_mut() 8791 8791 + .insert( 8792 8792 + GrpcMethod::new( 8793 8793 + "rockbox.v1alpha1.SystemService", 8794 8794 + "GetRockboxVersion", 8795 8795 + ), 8796 8796 + ); 7593 8797 self.inner.unary(req, path, codec).await 7594 8798 } 7595 8799 pub async fn get_global_status( 7596 8800 &mut self, 7597 8801 request: impl tonic::IntoRequest<super::GetGlobalStatusRequest>, 7598 7598 - ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status> 7599 7599 - { 7600 7600 - self.inner.ready().await.map_err(|e| { 7601 7601 - tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 7602 7602 - })?; 8802 8802 + ) -> std::result::Result< 8803 8803 + tonic::Response<super::GetGlobalStatusResponse>, 8804 8804 + tonic::Status, 8805 8805 + > { 8806 8806 + self.inner 8807 8807 + .ready() 8808 8808 + .await 8809 8809 + .map_err(|e| { 8810 8810 + tonic::Status::unknown( 8811 8811 + format!("Service was not ready: {}", e.into()), 8812 8812 + ) 8813 8813 + })?; 7603 8814 let codec = tonic::codec::ProstCodec::default(); 7604 8815 let path = http::uri::PathAndQuery::from_static( 7605 8816 "/rockbox.v1alpha1.SystemService/GetGlobalStatus", 7606 8817 ); 7607 8818 let mut req = request.into_request(); 7608 7608 - req.extensions_mut().insert(GrpcMethod::new( 7609 7609 - "rockbox.v1alpha1.SystemService", 7610 7610 - "GetGlobalStatus", 7611 7611 - )); 8819 8819 + req.extensions_mut() 8820 8820 + .insert( 8821 8821 + GrpcMethod::new("rockbox.v1alpha1.SystemService", "GetGlobalStatus"), 8822 8822 + ); 7612 8823 self.inner.unary(req, path, codec).await 7613 8824 } 7614 8825 } ··· 7620 8831 dead_code, 7621 8832 missing_docs, 7622 8833 clippy::wildcard_imports, 7623 7623 - clippy::let_unit_value 8834 8834 + clippy::let_unit_value, 7624 8835 )] 7625 8836 use tonic::codegen::*; 7626 8837 /// Generated trait containing gRPC methods that should be implemented for use with SystemServiceServer. ··· 7629 8840 async fn get_rockbox_version( 7630 8841 &self, 7631 8842 request: tonic::Request<super::GetRockboxVersionRequest>, 7632 7632 - ) -> std::result::Result<tonic::Response<super::GetRockboxVersionResponse>, tonic::Status>; 8843 8843 + ) -> std::result::Result< 8844 8844 + tonic::Response<super::GetRockboxVersionResponse>, 8845 8845 + tonic::Status, 8846 8846 + >; 7633 8847 async fn get_global_status( 7634 8848 &self, 7635 8849 request: tonic::Request<super::GetGlobalStatusRequest>, 7636 7636 - ) -> std::result::Result<tonic::Response<super::GetGlobalStatusResponse>, tonic::Status>; 8850 8850 + ) -> std::result::Result< 8851 8851 + tonic::Response<super::GetGlobalStatusResponse>, 8852 8852 + tonic::Status, 8853 8853 + >; 7637 8854 } 7638 8855 #[derive(Debug)] 7639 8856 pub struct SystemServiceServer<T> { ··· 7656 8873 max_encoding_message_size: None, 7657 8874 } 7658 8875 } 7659 7659 - pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 8876 8876 + pub fn with_interceptor<F>( 8877 8877 + inner: T, 8878 8878 + interceptor: F, 8879 8879 + ) -> InterceptedService<Self, F> 7660 8880 where 7661 8881 F: tonic::service::Interceptor, 7662 8882 { ··· 7711 8931 "/rockbox.v1alpha1.SystemService/GetRockboxVersion" => { 7712 8932 #[allow(non_camel_case_types)] 7713 8933 struct GetRockboxVersionSvc<T: SystemService>(pub Arc<T>); 7714 7714 - impl<T: SystemService> 7715 7715 - tonic::server::UnaryService<super::GetRockboxVersionRequest> 7716 7716 - for GetRockboxVersionSvc<T> 7717 7717 - { 8934 8934 + impl< 8935 8935 + T: SystemService, 8936 8936 + > tonic::server::UnaryService<super::GetRockboxVersionRequest> 8937 8937 + for GetRockboxVersionSvc<T> { 7718 8938 type Response = super::GetRockboxVersionResponse; 7719 7719 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8939 8939 + type Future = BoxFuture< 8940 8940 + tonic::Response<Self::Response>, 8941 8941 + tonic::Status, 8942 8942 + >; 7720 8943 fn call( 7721 8944 &mut self, 7722 8945 request: tonic::Request<super::GetRockboxVersionRequest>, 7723 8946 ) -> Self::Future { 7724 8947 let inner = Arc::clone(&self.0); 7725 8948 let fut = async move { 7726 7726 - <T as SystemService>::get_rockbox_version(&inner, request).await 8949 8949 + <T as SystemService>::get_rockbox_version(&inner, request) 8950 8950 + .await 7727 8951 }; 7728 8952 Box::pin(fut) 7729 8953 } ··· 7753 8977 "/rockbox.v1alpha1.SystemService/GetGlobalStatus" => { 7754 8978 #[allow(non_camel_case_types)] 7755 8979 struct GetGlobalStatusSvc<T: SystemService>(pub Arc<T>); 7756 7756 - impl<T: SystemService> 7757 7757 - tonic::server::UnaryService<super::GetGlobalStatusRequest> 7758 7758 - for GetGlobalStatusSvc<T> 7759 7759 - { 8980 8980 + impl< 8981 8981 + T: SystemService, 8982 8982 + > tonic::server::UnaryService<super::GetGlobalStatusRequest> 8983 8983 + for GetGlobalStatusSvc<T> { 7760 8984 type Response = super::GetGlobalStatusResponse; 7761 7761 - type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 8985 8985 + type Future = BoxFuture< 8986 8986 + tonic::Response<Self::Response>, 8987 8987 + tonic::Status, 8988 8988 + >; 7762 8989 fn call( 7763 8990 &mut self, 7764 8991 request: tonic::Request<super::GetGlobalStatusRequest>, 7765 8992 ) -> Self::Future { 7766 8993 let inner = Arc::clone(&self.0); 7767 8994 let fut = async move { 7768 7768 - <T as SystemService>::get_global_status(&inner, request).await 8995 8995 + <T as SystemService>::get_global_status(&inner, request) 8996 8996 + .await 7769 8997 }; 7770 8998 Box::pin(fut) 7771 8999 } ··· 7792 9020 }; 7793 9021 Box::pin(fut) 7794 9022 } 7795 7795 - _ => Box::pin(async move { 7796 7796 - let mut response = http::Response::new(empty_body()); 7797 7797 - let headers = response.headers_mut(); 7798 7798 - headers.insert( 7799 7799 - tonic::Status::GRPC_STATUS, 7800 7800 - (tonic::Code::Unimplemented as i32).into(), 7801 7801 - ); 7802 7802 - headers.insert( 7803 7803 - http::header::CONTENT_TYPE, 7804 7804 - tonic::metadata::GRPC_CONTENT_TYPE, 7805 7805 - ); 7806 7806 - Ok(response) 7807 7807 - }), 9023 9023 + _ => { 9024 9024 + Box::pin(async move { 9025 9025 + let mut response = http::Response::new(empty_body()); 9026 9026 + let headers = response.headers_mut(); 9027 9027 + headers 9028 9028 + .insert( 9029 9029 + tonic::Status::GRPC_STATUS, 9030 9030 + (tonic::Code::Unimplemented as i32).into(), 9031 9031 + ); 9032 9032 + headers 9033 9033 + .insert( 9034 9034 + http::header::CONTENT_TYPE, 9035 9035 + tonic::metadata::GRPC_CONTENT_TYPE, 9036 9036 + ); 9037 9037 + Ok(response) 9038 9038 + }) 9039 9039 + } 7808 9040 } 7809 9041 } 7810 9042 }