This is a rebased version of !522, with the same key changes.
* `PairingFragment` and `SystemVolumeFragment` are now written in Kotlin
* A new `BaseFragment` defines a common 'binding' property for `AboutFragment`,
`DeviceFragment`, `PairingFragment`, and `SystemVolumeFragment`
* Calls in and out of `Intent`s and `Bundle`s for `Parcelable` values now go through `IntentCompat` and `BundleCompat`
After upgrading to Android 15 I noticed the automatic clipboard push from Android stopped working,
debugging it, figured out that it looks like the format of lines in the logcat has changed,
this patch got it working again.
So we can see crashes in previous sessions of the app. Also, Android only
lets apps see their own logs anyway (at least in recent versions), so there
should be no privacy concerns from someone sharing those logs.
## Summary
Previously, URLs shared to offline targets via the ShareActivity were
delivered to them once they became online. This change extends this
behavior to direct share targets.
## Test Plan
Test 1
* Make sure a PC device is already paired with the phone. Let's say the name of this device is "PC".
* Make PC unreachable, e.g., close the KDE app on it.
* On the phone, open Chrome and share a couple of webpages to KDE's PC's direct share target.
* Open the KDE app on the PC.
* Observe that the webpages are opened on PC.
Test 2
* Make sure a PC device is already paired with the phone. Let's say the name of this device is "PC".
* Make PC unreachable, e.g., close the KDE app on it.
* On the phone, share a file to KDE's PC's direct share target.
* Open the KDE app on the PC.
* Observe that the file is sent to PC.
Test 3
* Make sure two PC devices are already paired with the phone. Let's say the name of these devices are "PC1" and "PC2".
* Make PC1 and PC2 unreachable, e.g., close the KDE app on them.
* On the phone, open Chrome and share a couple of webpages to KDE's PC1's direct share target.
* Open the KDE app on the PC2.
* Observe that the webpages are NOT opened on PC2.
* Open the KDE app on the PC1.
* Observe that the webpages are opened on PC1.
Test 4
* Make sure a PC device is already paired with the phone. Let's say the name of this device is "PC".
* Make PC reachable, e.g., have the KDE app open on it.
* Try to share a URL from the phone to the KDE's PC's direct share target.
* Observe that the URL opens instantly on the PC.
Some Android versions seem to hang if calling sslSocket.getOutputStream()
from within the HandshakeCompleted callback (maybe because calling it in
on a socket that hasn't finished the SSL handshake is supposed to trigger
the SSL handshake).
BUG: 501241
Reading the docs, BufferedReader maybe could read and cache more than one
line from the socket, and since we discarded the BufferedReader and
created a new one (up to three times), data could be lost.
- Solved serialization issue when commas were used
- Validate hosts and show toast message if host is invalid
- Show whether device can be reached over the network
- Show toast message when host already exists
- Code TODO's (including sorting device list)
This commit simplifies the `checkRequiredPermissions` method in the `RemoteKeyboardPlugin` by using Java
streams.
The previous implementation used a for loop to iterate over the list of enabled input methods and check if the package name matched the current context. This has been replaced with a more concise stream-based approach using `anyMatch`.
On Android 10 the share files feature fails when the default
directory is selected. When selecting a custom directory, the
permission is explicitly asked to the user, which makes the
feature work. When the location is switched back to the default
location, the feature is again broken.
The requestLegacyExternalStorage flag brings back the old
behavior and allows to write in the directory. It should be however
ignored for Android >= 11 according to the docs:
https://developer.android.com/training/data-storage/use-cases#opt-out-in-production-app
From Android 11, the Downlods directory should not need specific permissions.
## Summary
1) Fix the code responsible for loading the trusted network list.
2) The old `#_#` delimiter has been replaced with a less likely NUL character. This requires re-adding trusted networks, so I can revert it if necessary.
3) Ignore incoming identity packets on untrusted devices if they come from an untrusted device.
BUG: 492302
## Test Plan
### Before:
1) Trusted networks were completely broken, an would show variations of `#` and `_` on the list due to a bug in the splitting code.
2) Any network with `#_#` in the SSID - although unlikely - would not be possible to use as a trusted network.
3) The device was still discoverable on an untrusted network by manually refreshing the devices list.
### After:
1) Trusted networks now load the SSID list correctly.
2) Networks with `#_#` in the SSID can be added as trusted networks.
3) The device is no longer discoverable on an untrusted network.
Auto reconfiguration of own certificate:
currently:
if kdeconncect loads its certificate and its expired or not effective yet
it generates a new certificate and deletes all remembered devices
(since these will stay unreachable anyways)
previously:
if kdeconncect loads its certificate and its expired or not effective yet
it continues having the same certificate
This brings forth an issue: Other devices would refuse to connect to a device with
an expired or non-effective certificate.
Auto-delete of orphan certificates:
currently:
Devices in kdeconnect's devicelist that have illegal ssl certificates
(expired, not effective yet, empty) get automatically deleted from the
devicelist
previously:
they would just exist forever until the user deletes them
This MR is a continuation of !439 , which changes the default
behavior of the remote mouse plugin's drag and drop trigger
to be a double-tap to drag, and adds a new SwitchPreference
that toggles between the old (hold to drag) and new behavior.
This commit adds functionality to notify the MediaStore when files are modified via SFTP. This ensures that
changes made through SFTP are reflected in the Android media library.
Specifically, the MediaStore is notified after file creation, deletion, copying, renaming, and link creation. Additionally, it is notified after closing a file that was opened for writing. This ensures that the MediaStore is kept up-to-date
with any changes made to files through SFTP.
NIO2 is the default IO Service of SSHD Core. But when Android SDK < 26, NIO2 doesn't exists. So we have to use Apache MINA as IO Service to fix this issue.
refactor: migrate `AndroidSshFile` to Kotlin
refactor: migrate `DHG14_256` to Kotlin
refactor: migrate `RootFile` to Kotlin
refactor: migrate `SftpPlugin` to Kotlin
refactor: migrate `SignatureRSASHA256` to Kotlin
refactor: migrate `SimpleSftpServer` to Kotlin
refactor: migrate `StoragePreference` to Kotlin
refactor: migrate `StoragePreferenceDialogFragment` to Kotlin
It was used by mistake in DeviceFragment inside a device.apply block
because it was shadowing the pairingCallback defined there.
Bug introduced in 23701bc4ae
PowerMock is no longer maintained and is only compatible with Mockito 3.
However, modern Mockito supports mocking static methods, so PowerMock is
no longer needed (after adjusting the tests a bit).
would throw a SecurityException and cause the app to crash. It will now ignore this
condition and keep using the other connection methods (i.e. LANProvider). Toggling the
Enable Bluetooth option in the settings will fix the permissions
Signed-off-by: Rob Emery <git@mintsoft.net>
We had a mix of specific colors and theme-based Material You colors.
This aims to remove any hardcoded color so the app only uses the colors
from the current theme.
Parameter specified as non-null is null: method
org.kde.kdeconnect.Plugins.MprisPlugin.MprisNowPlayingFragment$connectToPlugin$2$1$1.onItemSelected,
parameter arg1
## Summary
A recent (couple of weeks ago?) change to the Invent policies requires that we use a docker image from an allow list.
The cleanest fix is to just use the Ubuntu base image and install the JDK, which is approximately what we had before.
We considered the Sysadmin Android image (https://invent.kde.org/sysadmin/ci-images/-/blob/master/android-qt66/Dockerfile?ref_type=heads), but we use a newer version of the SDK tools and a newer version of the JDK, at which point we may as well just install those since those are the only dependencies. We could consider building another custom docker image in the future if we see value to doing so.
## Test Plan
### Before:
CI fails with:
```
ERROR: The "eclipse-temurin:17-jdk-focal" image is not present on list of allowed images:
- invent-registry.kde.org/sysadmin/ci-images/*:*
- ubuntu:*
- debian:*
- fedora:*
- centos:*
- opensuse/*:*
- python:*
- ruby:*
- fsfe/reuse:*
- quay.io/podman/stable:*
```
### After:
Build passes and drops .apk
Kapt, short for Kotlin Annotation Processing Tool, serves as a replacement for annotationProcessor in Kotlin projects. It enables annotation processing in Kotlin by compiling Kotlin code into Java stubs, which are then processed as regular Java code. This allows for seamless integration of annotation processing in Kotlin projects, including handling existing Java code.
I'm not sure why and I've not found anything documented for this yet, but if we
flip the UUID and compare, it connects to a laptop fine and functions as well as
Android 13
## Summary
This fixes execution on gitlab. The newer version of `sdkmanager` has
different expectations, so we now create a directory for the SDK first
and move `cmdline-tools` into that.
Other changes:
- More inline comments
- Cmdline tools (like sdkmanager) added to path
- Platform tools (like adb) removed from path
- 'patcher' is no longer installed
## Summary
This contains some minor code quality improvements in
`RunCommandControlsProviderService`, as well as the following feature changes:
* If the device for a Device Control is reachable, clicking on the secondary
space of the control will launch RunCommandActivity. If the device isn't
reachable, we launch the MainActivity like usual.
* Pixel 7 and other modern Google devices can now show KDE Connect commands
in the 'Home' quick access tile (you still have to 'add app')
## Test Plan
0. Make sure your Android OS supports Device Controls (Android 11+)
1. Choose a paired device to work with
2. Place at least one command in the Run Command list
3. Enable the command in the Device Controls screen
4. Test what happens when you click on the secondary space of the control
We have NPE reports from the line mpris.fetchedAlbumArt(url.toString()).
I'm not sure if it's because mpris is null or url is null. Spliting in two
lines to see where the crash actually happens.
This should fix SFTP not working when using GSConnect (which
doesn't specify the SSH parameters we do to allow old cyphers).
Requires API 23, so on pre-23 we still use RSA.
The contacts plugin is the only one that copies (and persists) data to the
remote device just by connecting. By adding this extra confirmation once
per device, we prevent this from happening in cases where someone paired
with a friend to transfer a file, or paired by accident.
As discussed in Matrix and BUG: 474121 this plugin is confusing (because
it doesn't actually take a photo, it just launches the camera on your
phone) and its use case can be covered by taking a photo and sharing it,
which only requires a couple extra clicks.
## Summary
Remove the dead "New Message" notification channel.
This channel was used for a tiny period, probably around 4 years ago, when we thought the only way to support sending MMS on Android was to be the default SMS app, thus we wanted to show users a notification when they received messages while our app was in charge of handling them.
Thankfully, we do not need to be the default SMS app, so this notification channel should be removed.
## Test Plan
### Before:
Looking at the list of notification streams in the settings for KDE Connect will include a "New Message" channel. Notifications are never posted to this channel.
### After:
Users will not see a "New Message" channel. Note that it does show a count of deleted streams, to prevent spam. See [documentation](https://developer.android.com/develop/ui/views/notifications/channels#DeleteChannel) for explanation.
Starting next month (September 2023) it will be required to target
Android 13 to publish to the Play Store.
On Android 13, we need to request the POST_NOTIFICATIONS permission.
This change adds the permission as required/optional to the plugins
that do create notifications. It also adds a popup to request it the
first time you open the app.
Fixes a race condition where onNetworkChange was called before the new
network became the default and the identity packet would be broadcast to
the wrong (e.g. cellular) network.
Allows navigating the app using the arrow keys on a keyboard or the
D-pad on a TV remote, up until the plugin list (I haven't checked
specific plugins).
Uses Android's `NsdManager` to announce a `_kdeconnect._udp` service using MDNS. This is done in addition to sending UDP broadcasts.
When we detect a device this way, we send a UDP identity packet to it (identical to the ones we broadcast but sent to a single device).
I also added a toggle in settings to disable the UDP broadcasts, so we can test MDNS by itself.
The Presenter activity including its layout file and related Java class were replaced with Compose UI.
Additionally, the androidx.compose.material3:material3 was updated from version 1.1.0 to version 1.1.1.
Sometimes we can't start the foreground service at boot for some reason.
I have a couple untested theories: either the phone is slow at boot and
we don't get to call startForeground in time, or the user has never
started the app before and we are not allowed to start it or to create a
notification.
`DeviceInfo` contains all the properties we need to instantiate a `Device`:
id, name, type, cert, capabilities and protocol version. Before, we had a mix
of passing those around as arguments or passing identity packets (ie: json).
This simplifies the `Device` class quite a bit.
Now, `BaseLink` subclasses need to implement the `getDeviceInfo()` interface
that returns a `DeviceInfo`, which is what we will pass around and eventually
use to instantiate a `Device`.
This means that identity packets are an implementation detail of the
`LanLinkProvider` and that other implementations could get the `DeviceInfo`
in a different way.
In a future, we can add a mechanism for links to notify when their `DeviceInfo` changed.
This will allow us to better support device renames (which now are implemented by
reconnecting to the device and don't always work) or sending the capabilities fields
later in the case of MacOS/iOS where we can't send them in a UDP packet due to the
size limit of 1500 bytes.
Bubble up exceptions instead of using giant, generic try-catch blocks.
The UDP and TCP listener loops are now where we catch all the exceptions that might happen handling the incoming packets.
Also, the creation of worker threads now happens in the listener loops as well instead of the inner functions.
Finally the `broadcastUdpPacket` function has been split in `broadcastUdpIdentityPacket` and `sendUdpIdentityPacket` (the first calls the second).
Since we now require API 21, we can use setAudioAttributes instead of
the deprecated setAudioStreamType.
Since we already require WAKE_LOCK for the SMS plugin, we can use it
here to prevent the screen from sleeping.
The version of the library we used stopped working in 2020 when the names
database it tries to download got deleted from the master branch of their
Github repo. There's a newer version, but it seems to have lost the
fetch-from-the-internet functionality (it only bundles a list of names) and
for some reason it crashes when I tested it (I've opened an issue on their
repo). Since Google now provides a CSV with all the Android device names
that exist, I've replaced the library by my own function that downloads the
CSV file (~3MB) in the first run of the app and looks for the name there.
By passing a port the implementation of DatagramSocket already binds to
it, making it fail if the port was already in use even if we did
setReuseAddress because that happened after binding.
And only create directories for languages that have a translation.
Otherwise, fastlane crashes trying to upload the translations.
After merging this I will manually delete the "bad" translations in the fastlane directory.
Creates .pot files from txt files in the en-US store metadata and then
does the oposite for po files translated to the respective languages.
This should allow the translation teams to translate the store descriptions.
Rewrites the RunCommand widget. Now we can have different widgets for
different devices at the same time. Also removes the startService call
that could cause ForegroundServiceStartNotAllowedException on API 12+.
We don't want to crash if we get onNetworkChange before tcpServer has been
initialized, however the way to do it was wrong because the exception was
being thrown from a new thread.
broadcastUdpPacket will throw if setupTcpListener isn't successful, and
at that point we no longer know the real issue. Re-throw exceptions in
setupTcpListener so we can see what goes wrong.
This is read by F-Droid, so it should fix our app not having an icon or
having outdated screenshots there.
Also, this can be used to update the Play Store by doing:
fastlane supply --version-code <version code> --json-key <path to key>
In a future, it would be nice to update the StaticMessages.sh script so
it converts the app description here to .pot and back so we can have KDE
localization teams translate it and updates are automatically picked up.
When playing music on Windows, we receive MPRIS player updates ~once per
second. This calls the MprisMediaSession updateMediaNotification function
which then calls updateCurrentPlayer which used to call
SystemVolumeProvider's startTrackingVolumeKeys (now renamed to
startListeningForSinks) which is quite bad because on each call:
* It would add yet another copy of this to the listeners list
* It would send a network packet to get the sinks from the other device
Now we only call startListeningForSinks when the tracked player changes.
Fixes the bug described in !359. Since we made sending packets sequential
in !90 (including the payload part of the packet) we could be blocking the
queue for up to 10 seconds if the other end didn't fetch our payload.
This makes the payload part async by default but keeps the option to make
it sync, since we want that behavior in CompositeUploadFileJob.
Added a new KdeConnect Application class that holds the Devices now, while
BackgroundService "only" takes care of the LinkProviders.
Since KdeConnect subclasses Application we have the guarantee that it will
exist as long as our process does, so we can use it as a singleton. This
removes the "BackgroundService.RunCommand" hack (which sent an Intent that
would awake BackgroundService in case it wasn't running already and then
call our code in a callback). This saves lots of round trips between the
system and us and makes things simpler (and stack traces useful) by making
the code sequential.
We already had an Application subclass that I moved to a new helper, which
now the KdeConnect class initializes together with all the other helpers.
## Summary
Gradle version bump in 921d0ee884 (probably) is incompatible with Java 11.
Fix Gitlab CI by increasing Java version, as required by latest Gradle version.
## Test Plan
### Before:
Gitlab CI does not work, complaining about Java version. See for example: https://invent.kde.org/network/kdeconnect-android/-/jobs/950701
### After:
Gitlab CI does work
TLSv1.2 is supported on all the Android versions we support now.
TLSv1.3 is only supported in API 29+. Although we could conditionally
enable it on 29+, it seems to cause problems (disconnects & reconnects
when the LanLink gets refreshed) also on newer devices.
Missing break statements causes sync issues and SMS to be parsed as MMS and leads to the URI of a SMS not being found within the MMS content and SMS sync failing.
This reverts commit 7efb1f81b5.
For some weird reason, mina-sshd works fine without desugaring NIO on
Android 5 but fails with `java.lang.NoClassDefFoundError: Failed resolution
of: Ljava/nio/channels/AsynchronousChannelGroup;` before reverting this
Apply Material3 to dialogs, image buttons, switches and preferences.
Merge the landscape and portrait layouts for the MPRIS controls.
Move setting theme to application start instead of applying to every activity.
- Add Monet dynamic colors on the app's `onCreate()`
- Set parent in styles.xml to `Theme.Material3.DayNight.NoActionBar`
- Use `MaterialAlertDialogBuilder`
- In the About and About KDE fragments, it uses the M3 elevated style instead of outlines
- In `edit_text_alert_dialog_view.xml`, it uses the default theme style instead of specifying the one from MaterialComponents
- Added a todo in the settings fragment: Preference dialogs don't yet use the M3 style.
It complements https://invent.kde.org/network/kdeconnect-android/-/merge_requests/273, though the way that merge request accomplishes color theming is the one from before the onCreate dynamics color method
Since Android 8, this ID is stable across reinstalls of the app. This
causes other devices that already were paired with us to find a cert
mismatch and refuse to communicate with us after a reinstall or data wipe.
* Remove usage of deprecated WiFi ConnectivityManager
* Only listen for non-cellular network changes (where we can find devices)
* Do not listen for network changes also from PairingFragment
## Summary
This MR adds gyro mouse capability, which allows you to move the cursor of a connected device by simply moving the connected phone. It uses standard Android gyroscope sensors. Mainly aimed at usage with computers attached to very large screens (e.g. TV's), as using the touchpad as-is can feel somewhat unnatural.
While it does attempt pretty much the same thing as !285, this MR attempts to reduce redundancy as much as possible by simply extending the existing MousePadPlugin instead.
Tested on a Xiaomi Redmi Note 11, on a Samsung A71, and on a laptop running Arch Linux and KDE Plasma 5.27.3
## Test Plan
1. Make sure the 'Remote Input' plugin is enabled on the Android device.
2. Make sure the 'Virtual Input' plugin is enabled on the target device.
3. Open Plugin Settings -> Remote Input for the target device.
2. Enable the toggle for Gyro mouse.
3. Exit settings and go to the Remote Input activity for the target device.
4. Try moving the device around in 3D space.
5. Confirm that the mouse pointer moves predictably.
Android 13 added the ability to select languages on a per-app basis. Supporting this feature simply requires us to provide a listing of all of the locales supported by the app: https://developer.android.com/guide/topics/resources/app-languages
This change adds a locales_config.xml file to list the locales and references this file in the application manifest
Add a debug and test CI. As the test coverage today is not much to get excited about, this is mostly a check that the app still builds, as well as a convenient way to download the prebuilt app for testing.
SpongyCastle was a fork of BouncyCastle needed before Android 3.0 because
of a conflict with Android's own version of BC. It's no longer needed and
rarely receives updates anymore [1]. Furthermore the version we were using
was from 2015 and had security issues (although I'm not sure we were
affected by them since we only use it to generate certificates).
With this change we now also use Java's standard library to read the certs
from a byte[] since the standard CertificateFactory can already do that.
[1] https://github.com/rtyley/spongycastle/issues/34
This fixes the bug introduced in f97216 which prevented configuring storage
locations because the plugin wasn't returned by `getPlugin` when there are
no storage locations present.
* Do not ask for WRITE_EXTERNAL_STORAGE in Android 11+ (writing to "Downloads" is [allowed by default since 11](https://stackoverflow.com/questions/70248631/starting-from-android11-do-i-need-to-comply-to-androids-saf-just-to-even-creat)).
* Do not check for permissions before receiving a file. Try and let it error out, instead of silently doing nothing.
* Fix not offering to open content:// urls (we checked the URLs to be file:// urls to then convert them to content://).
* Better permission explanation text.
Removes conditional code for older Android versions (IceCreamSandwitch, JellyBean, KitKat, Lollipop) since we no longer support Android older than Lollipop (5.0).
This doesn't remove KitKat support in the SFTP plugin since it's a bit more convoluted. It will be done in a separate MR.
On Android 10 and above, Clipboard needs to be manually sent. Recently the app was shipped with the patches so that users can use adb to grant the required permissions for automatic clipboard propagation.
In case the permissions were granted for automatic clipboard propagation, 'Send Clipboard' option was hidden from persistent notification but was not removed from the DeviceFragment. This MR addresses this.
Certain implementations of the protocol (namely GSConnect) use UUIDS
for the device IDS/command keys, which contain hyphens in them. The
current implementation of RunCommandControlsProviderService (used for
the android 11 power menu command control things) gives the controls
unique IDS with "{deviceid}-{commandkey}" and then tries to split on the
hyphen, which obviously breaks if the device id or command key contain
hyphens. This patch changes it to uses colons to separate them instead.
Note that I've only tested this with GSconnect, but I see no reason why
it wouldn't work with the normal KDE connect implementation too, unless
it uses colons in IDs.
## Summary
Android apps which target SDK 31+ require specifying the mutability of any PENDING_INTENT. This is not supported in the upstream android-smsmms library: https://github.com/klinker41/android-smsmms/pull/193
Until the above PR is merged, we need a solution. I have pulled the code into https://invent.kde.org/sredman/android-smsmms and published the package in the Maven repository in gitlab.
BUG: 464392
## Test Plan
### Before:
Attempting to send an SMS or MMS message using kdeconnect-sms results in no message being sent, and an error being logged:
> V/Sending message: Sending new SMS
> E/Sending message: Exception
> java.lang.IllegalArgumentException: org.kde.kdeconnect_tp: Targeting S+ (version 31 and above) requires that one of FLAG_IMMUTABLE or FLAG_MUTABLE be specified when creating a PendingIntent.
> Strongly consider using FLAG_IMMUTABLE, only use FLAG_MUTABLE if some functionality depends on the PendingIntent being mutable, e.g. if it needs to be used with inline replies or bubbles.
> at android.app.PendingIntent.checkFlags(PendingIntent.java:382)
> at android.app.PendingIntent.getBroadcastAsUser(PendingIntent.java:673)
> at android.app.PendingIntent.getBroadcast(PendingIntent.java:660)
> at com.klinker.android.send_message.Transaction.sendSmsMessage(Transaction.java:267)
> at com.klinker.android.send_message.Transaction.sendNewMessage(Transaction.java:158)
> at com.klinker.android.send_message.Transaction.sendNewMessage(Transaction.java:172)
> at org.kde.kdeconnect.Plugins.SMSPlugin.SmsMmsUtils.sendMessage(SmsMmsUtils.java:188)
> at org.kde.kdeconnect.Plugins.SMSPlugin.SMSPlugin.onPacketReceived(SMSPlugin.java:414)
> at org.kde.kdeconnect.Device.onPacketReceived(Device.java:570)
> <snipped for brevity>
### After:
SMS and MMS sends normally.
## Summary
Fix a logic error in the SMS plugin which caused it to skip the addresses of other targets when reporting group messages.
Notionally, this bug originated with the logic change in !197, where everything switched to using the android-smsmms library.
BUG: 464555
## Test Plan
### Before:
Group messages would be returned as single-target messages between you and the sender, meaning the desktop app would have a bad time showing them.
### After:
Group messages are returned with the appropriate list of addresses, the desktop app groups them appropriately.
With the old logic, the mostRecentTimestamp would effectively only be updated once, the first time the app noticed an SMS/MMS. This means that, until the app was next closed, it would return every message sent or received after that timestamp. Since the app doesn't crash as often as it used to, this can grow to a quite significant number of messages.
The Play Store asks us a video showing why we need the accessibility
service, and I can't make it work so I can't record the video.
Removing this plugin removes the need for any accessibility permissions.
Motivation: We can't publish to the Play Store with a targetSdkVersion < 31
The new targetSdk required two changes:
* Specifying when activities, services and receivers should be exported or
not to other apps. For the ones I wasn't sure of what we want, I made
them exported to not break something.
* Specifying when a PendingIntent should be mutable or immutable. I made
them all mutable for now.
## Summary
Since a lot of devices now have Android 13, some users might want support for the new themed app icons.
This adds support for these, by adding a monochrome drawable (just the default icon with only the phone border and K) in `res/drawable-v24/ic_launcher_monochrome.xml` and then referencing this in `res/minimap-anydpi-v26/ic_laucher(_round).xml`.
## Test Plan
This can be tested by simply compiling and installing the app as usual on any device running Android 13.
After installing the app, the option for an adaptive colour theme will need to be enabled:
- OneUI5: Long-press home screen > Wallpaper and Style > Colour palette > enable colour palette and check "Apply palette to app icons"
- Pixel: Long-press home screen > Wallpaper & style > check "Themed icons"
The app icon should now follow the system theme (on some devices only on home screen, on others both home screen and app drawer).

## Summary
Clean up a bunch of lint errors in SMSHelper.java. Some of these are null issues which in theory might prevent a crash.
## Test Plan
No functional changes are expected. Fetching SMS still works for me.
## Summary
Spawning new threads in Java is costly. This MR aims to use a common thread pool instead.
I've replaced all cases where a new thread is started just to perform a task in the background. This does not include cases where a reference to the newly created thread is kept as a part of application logic – this is probably a problem in itself, but it exceeds the scope of this quick optimization. ;)
There was a couple of cases where a new thread was spawned just to sleep for a while an then change the state on a View on the main thread. I've replaced those with posting those deferred tasks to the View's message queue.
## Test Plan
Everything should work the same as it has before, just a bit faster and easier on the memory.
Colors don't work in some cards, menus and the hamburger menu
## Summary
I'm trying to make KDEConnect pull colours from the Material 3.0
wallpaper in Android 12. I've managed to do this to an extent by editing
the xml files in res/values*. There are, however, certain UI elements
that do not respond to the changes I've made, with no obvious files
where their colours may be changed.
## Screenshots
### The devices screen looks great (Except "KDE Connect Devices" in the
App bar isn't themed.)

### The hamburger menu has a white color in light mode. Don't know where
this is set and how to change it

### Three dot menu has a white colour

### Add new devices looks good too

### Not the popup menus though

### Cards in the About section are still white

### Dark mode works fine

### But again, some UI elements like the hamburger menu aren't themed.

I'll keep trying to figure out how to make these elements to their
proper colours, but I've done a lot of searching through the source and
couldn't figure out how. I'm absolutely new to Android development. Help
please.
## Test Plan
For the changes made thus far, none are needed.
## Summary
Since !158, fetching messages has been painfully slow. This is because, instead of making one cursor (database) call, we needed to make two per conversation.
Unless someone finds a conversations URI which works on Samsung devices and reliably returns data, there isn't much we can do about that. What we can do, is return each conversation more quickly to get the UI populated and to prevent blocking the main thread forever.
This attempts to return conversations ordered by most-recent first. If the conversations URI returns junk for the thread date, it will return in an undefined order.
## Test Plan
#itworksforme
Official gradle docs recommend using settings.gradle file (see https://docs.gradle.org/current/userguide/organizing_gradle_projects.html#always_define_a_settings_file).
Blank Android projects in Android Studio declare their name and repositories in settings.gradle. Therefore, it makes sense to create such file here and add that information in it.
An explicit project name allows us to know exactly to what `project.name` resolves, instead of relying on the project root directory name, which can be changed by the developer locally.
## Summary
Fixed MprisActivity crash in landscape orientation caused by mismatched portrait and landscape layout resources
BUG: 435016
## Test Plan
### Before:
App crashed on MprisActivity when phone is switched to landscape orientation
### After:
App works normally in landscape mode
Allows to control the volume of the default sink of the remote device by pressing phone volume keys on API21+ (Lollipop and onwards) when MPRIS session is active (i.e. MPRIS media control notification is present). Remote device should support System Volume Plugin and report its default sink. Volume controlling works both when the phone screen is off and on. When the screen is on, you'll see a new slider in the volume panel.
BUG: 398848
## Summary
Currently, KDE Connect for Android doesn't show the last 2 characters of the verification key when pairing a device. This MR solves this issue.
This bug is caused by incomplete conversions from byte arrays to strings in `SslHelper.java`:
```java
for (int i = 0; i < hash.length - 1; i++) {
formatter.format("%02x", hash[i]);
}
```
The ```i < hash.length -1``` converts the bytes in the array up to (inclusive) the penultimate one. Removing the ```- 1``` allows for the last byte to be converted (this is the missing 2 characters).
BUG: 445955
## Test Plan
### Before:
Selecting a desktop from the available devices, then clicking the `Request Pairing` button causes a 62 character key to be displayed. It is 2 characters short of the actual key, which can be seen on the desktop KDE Connect app.
### After:
Selecting the `Request Pairing` button now shows the whole verification key, as intended.
The Settings and About fragments are arguably one logical layer below the PairingFragment (which feels like the "main screen").
Capture the back press and return to the PairingFragment.
Fixes https://bugs.kde.org/show_bug.cgi?id=442716.
Notes:
- In a DeviceFragment back-pressing continues to close the app, as before. Judging from the fact that the app persists the last selected device to the shared prefs, I assume this is a intentional.
- I also thought about storing from where the Settings/About were opened (e.g. from a specific DeviceFragment) and returning there. However this would be a much larger change with arguable user benefit. After all, from the PairingFragment it's just a single click to your device.
Set the title "Settings" to the action bar in the SettingsFragment.
Previously, depending on where you came from, it just read "KDE Connect Devices", "About" or the device name.
## Problem
On Android 10 (API 29) or later, when a trusted network has been configured, if the mobile device rejoins the network while KDE Connect is running in the background, it doesn't reconnect to any paired devices in the trusted network. It only reconnects when the user brings the app to the foreground.
## Cause
Android 10 introduced [a separate permission for background location access](https://developer.android.com/about/versions/10/privacy/changes#app-access-device-location).
When KDE Connect is running in the background with API 29+, [`TrustedNetworkHelper.currentSSID` fails to get the SSID](d22967f475/src/org/kde/kdeconnect/Helpers/TrustedNetworkHelper.java (L77)) because it doesn't have the required permission. This prevents KDE Connect from verifying whether a network is trusted.
## Solution
Make KDE Connect request for background location access permission.
To request for background location access, an app must [declare it in the manifest](https://developer.android.com/training/location/permissions#background), or else the option to to enable background location access won't appear in settings.
As a side note, the permission request dialog in `TrustedNetworksActivity` doesn't require changes because after Android 11, the option to allow background location no longer shows up in a dialog. [It has to be manually enabled in settings.](https://developer.android.com/training/location/permissions#background-dialog-target-sdk-version)
## Test Plan
### Before:
On Android 10 or later, configure a trusted network and pair with a device in it. Let KDE Connect run in the background. Disconnect from the trusted network and then rejoin. KDE Connect won't automatically reconnect to the paired device.
### After:
Do the same steps as above, except after configuring the trust network, go into settings and allow KDE Connect to access location all the time. After KDE Connect rejoins the trusted network, it should automatically reconnect to the paired device.


Adds the Android 8+ style adaptive icons, using the app's highlight color for extra contrast against the current fallback white background behind the white phone border. This new icon follows the size and grid guidelines of material design, and was created as a 108dp@1x svg
Added a screen to allow users to compose the key strokes to send. This is necessary because the keyboard that appears on the mouse pad screen does not have the voice to text microphone button on my phone. Even if it could be made to appear as it does on my tablet, some kind of text buffering is necessary because the voice text will change its mind.
## Summary
A basic mouse receiver implementation. You can now control your Android Device remotely which might be useful when it's connected to a bigger screen (via HDMI).
Unfortunately Android does not provide moving mouse by software (other than adb and without root). Therefore this implementation uses Android [AccessibilityService](https://developer.android.com/reference/android/accessibilityservice/AccessibilityService) to create an ImageView Overlay as mouse pointer and simulate touch gestures.
This is quite hacky but I think the best way to do so.
## Demo
Here is a small demo

Changes:
1. Add toolbar
2. Add device icons
3. Fix unexpected on-screen keyboard popping up when starting an activity on some Android versions
4. The distance between the device list and the text box has been reduced
This plugin lets you monitor the signal strength of the mobile connection of the phone,
so you may know if opening a hotspot is viable, or figuring out why a connection dropped while hotspot-ing.
## Summary
Add support for handling message request packets which have a list of attachments
## Test Plan
- Sent message with no attached file from desktop which was sent and received correctly
- Sent message with attached file from desktop which was sent and received correctly
- Sent message with two attached files which was sent and received correctly
Adds new functionality to the MousepadPlugin to accept data via Intent and pass them on to the host as keystrokes via the existing MousePadPlugin.PACKET_TYPE_MOUSEPAD_REQUEST PackageType
eg. to easily send OTP codes from the phone to the Desktop
Changes:
1. In the menu, the design of the selected item was changed, the icon of the current device was added and the image was removed
2. Changed the accent color to orange
3. Separators have been removed from almost all lists
4. The design of the selected item was changed in the menu, the icon of the current device was added and the image was removed
4. Changed the color of the toolbar to white or black (depending on the theme)
Since commit f3ada9738d, the app crashes with a ClassCastException when going into the "expose filesystem" menu.
This is because view binding checks if the root view is the one it expects but the one passed here isn't directly the checkbox layout but instead the whole StoragePreference layout.
Because there is one view to bind, view binding here doesn't make much sense so replace it with a findViewbyId().
Also add viewBindingIgnore="true" to the view so its binding class is
not generated.
The key is a sha256 of both devices' certificates. Both should generate the
same key, so hey user can check they are pairing against the right device.
Thanks Matthias Gerstner <mgerstner@suse.de> for reporting this.
Revert a7a66ecb2b which accidentally confused two very similar method names
Rename those methods to make sure it's clearer for anyone else who reads this code in the future
This fixes an issue with the first sync of threads not returning the actual most-recent message if the most-recent message was an MMS with no plain-text body
When we trigger a refresh and immediately navigate away from the list the view is destroyed and the refreshing end callback is accessing the now null devicesListBinding
## Summary
Use `content://mms-sms/conversations?simple=true` instead of just `content://mms-sms/conversations` which should work for more devices (and is reported to work on Samsung devices)
For some reason, this misses exactly one conversation on my phone and throws back one invalid thread ID -- I suspect this indicates that my message database is corrupt 🤷
BUG: 401677
## Test Plan
### Before:
Lots of devices were not able to retrieve conversations. See [bug 401677](https://bugs.kde.org/show_bug.cgi?id=401677)
### After:
Hopefully all devices are able to retrieve conversations. At minimum, hopefully there are no regressions :)
- Due to Android 10 restrictions, background tasks can no longer launch activities
- Post a notification instead when a URL is received and KDE Connect is not in foreground
This reverts 3 commits:
"Clipboard Plugin: Added support to send clipboard to multiple devices on Android 10 and later."
b92271105a
"Excluded ClipboardFloatingActivity from App recents Screen"
ee1562050c
"Make Clipboard plugin work in Android X"
b81d3a82e5
## Summary
Fixes#5
BUG: 417419](https://bugs.kde.org/show_bug.cgi?id=417419)
This patch introduces a workaround to access the restricted clipboard in Android X.
Clipboard synchronisation in KDE Connect was one of the killer features before Android X. An action button is added in the persistent foreground notification **Send Clipboard** which adds the ability to send the clipboard using a small workaround. Clipboard Synchronisation works as usual in lower Android Versions.
This is a very convenient workaround for sending clipboard quickly as it does not requires to open the app. Floating Activity is quite handy for quick actions.
## Details of the workaround
### ClipboardFloatingActivity
* This activity is only executed in Android X.
* This is transparent, accesses the clipboard when in focus.
* Sends a `NetworkPacket` containing *text* and *timestamp*.
* When the packet has been sent, it pops up a toast with a success message.
* Automatically closes after the showing the Toast.
### Reverted changes for Android X.
* Changes done in commits 54be4a1a99 and 9f3b75b748 have been reverted.
* These changes are not required anymore as the workaround for clipboard sync works.
The action button in the notification for **Send Clipboard** is not added in the lower versions of Android. **It is only added in Android X**.
**Two way sync is working in Android X with this patch. Sync works normally in lower Android versions.**
## Test Plan
### Before:
Clipboard from PC to Phones were synchronised but Clipboard of phones didn't get synchronised with the PC.
### After:
The action button is up in Android X while using other apps.

After clicking the button, a cute Toast appears with the message *Clipboard sent*

I think this is one of the best workarounds available to make this awesome plugin work.
## Summary
This patch adds an interface to return only a specified window of messages.
The current implementation of the conversation interface loads all messages every time the conversation is requested. This is might be painfully slow to load in case the conversation is large or if there are a lot of MMS/RCS messages in the conversation (since those are wildly slower to load than SMS)
Used by https://invent.kde.org/kde/kdeconnect-kde/merge_requests/203 to enable Desktop functionality
## Test Plan
- With new Android app and old Desktop app:
- The Android app will notice the missing fields and query for all messages as before.
- With old Android app and new Desktop app:
- The desktop will send fields for the new interface which will not be read and all messages will be returned.
- With new Android app and new Desktop app:
- The new interface is used and returns only a certain number of messages at a time.
## Known Issues
There is an un-covered corner case if lots of MMS messages are received in the same second (or SMS messages in the same millisecond): Since the interfaces uses timestamps as a filter, it might happen that not all messages sharing the same timestamp are returned. The fact that there are still more messages sharing the timestamp is invisible to the caller. This could be a real-world problem if, for example, a user gets off a plane and their phone downloads a bunch of MMS all at once.
Seek position is preserved for following domains:
youtube.com
youtu.be
pornhub.com
vimeo.com
dailymotion.com
twitch.tv
ic_arrow_black.xml was converted from Kubuntu 19.10 AMD64
breeze-icon-theme package:
/usr/share/icons/breeze-dark/actions/32/arrow.svg
Some (Xiaomi) devices running >= Android Lollipop (SDK 22+) don't
support `Telephony.Sms.SUBSCRIPTION_ID`.
This commit adds a verification step to ensure that only devices with
`"sub_id"` column include it in query.
* Address review comments
Check was moved to a separate helper function (boolean), it's
performed only on SDK 22+ and `Telephony.Sms.SUBSCRIPTION_ID`
is used in query (instead of null), so no NullPointerException
is thrown.
Also parseInt shouldn't now fail if `Message.SUBSCRIPTION_ID` key
exists in messageInfo, but value is null
* Return false if cursor is null
* Return true without checking column
If we got the cursor, the query won't fail when executed again, and the "sim_id" column must exist (because an exception wasn't thrown).
Summary: I have created a new activity that allows you to trust all networks or add networks one by one to a list when you are connected to that network
Test Plan:
Test Cases:
1. By default everything should works like it works before, If you uncheck the "Allow all" option in trusted network menu and there isn't any ssid in the trusted
network list the app doesn't send the first udp package and log "Current WiFi isn't a Trusted Network"
2. With the "Allow all" uncheck, use "Add: YOUR_SSID_NAME" button to add your current ssid to the trusted networks list, once you added, go back and the app should
works as always
{F6152314}
1 -> https://youtu.be/ZpCEFTstbJI
2 -> https://youtu.be/cVB1LXlFVyk
Reviewers: #kde_connect, jdvr
Subscribers: sredman, albertvaka, nicolasfella, apol, kdeconnect
Tags: #kde_connect
Maniphest Tasks: T8539
Differential Revision: https://phabricator.kde.org/D13505
This method does not work because the API doesn't provide the information we need.
If we decide to ressurect it, we can look this commit up later.
#TIMECAPSULE
In version 1.1.0 of androidx, preferences do nothing on click if they are
not selectable. Added a new property "inSelectionMode" that we can use
instead of the built-in "selectable".
This way, when installing a development version built on a different
environment, it will be signed with the same key and Android won't make
you wipe your data.
Summary: Timestamp on changes to clipboards so that when a new device connects it can sync both clipboards to the most recent updated clipboard.
Reviewers: #kde_connect, albertvaka
Reviewed By: #kde_connect, albertvaka
Subscribers: albertvaka, sredman, kdeconnect
Tags: #kde_connect
Differential Revision: https://phabricator.kde.org/D22585
This was causing problems when a restored app remembered the list of
storage locations it had access to, but it no longer could access them.
In the past, this also caused problems when a restored app would carry
with it a certificate that was no longer valid on the new device because
the device id had changed.
BUG: 406707
Summary:
The methods in Device.java can be used from any thread, while
the methods in BaseLink (and its subclasses) should only run
on a background thread. These annotations are picked up by Lint
to show warnings and have no effect at runtime.
This also allows "unsending" packets (if they're still in the queue).
This patch does that for mouse move packets, so they get accumulated
together (sending less stuff over a congested link).
## Summary
Export the complete list of remote addresses of a multitarget message
Note that this changes format of the returned Message object, replacing the string "address" field with a string list "addresses" field, so it is not backwards-compatible with old desktop applications
## Test Plan
See Test Plan of the desktop-side patch: https://invent.kde.org/kde/kdeconnect-kde/merge_requests/101
- Update README with new links
- Add a section pointing potential translators to the localization team
- Add a quick text file to the strings folder to again point potential translators to the localization team
Summary:
Fixes an error of extracting SpannableString as String (which resulted in notification text being null).
Fixes group conversation text extraction on API <28.
Also includes some minor refactoring.
Reviewers: nicolasfella
Reviewed By: nicolasfella
Subscribers: kdeconnect
Tags: #kde_connect
Differential Revision: https://phabricator.kde.org/D22140
The lock should be kept between the point we read and the point we write
Also, no need to pass SMSPlugin as a parameter, since enclossed classes
already have access to its parent by default.
We had a list of names before, but it was outdated. Using a library gives
us an up-to-date list plus a fallback that fetches the name from the
internet if not in the list.
According to some information I stumbled across while working on a different issue, Samsung devices do not support the content provider I was using to populate the list of SMS conversations. This is very annoying, but nevertheless there appears to be a workaround.
BUG: 401677
Many users with Samsung devices have reported problems using the SMS plugin.
Hopefully this will fix the SMS plugin on Samsung devices.
## Summary
Not having support for MMS caused some minor problems, like in https://bugs.kde.org/show_bug.cgi?id=398889 . This patch adds basic MMS support for plain-text MMS, including multi-target messages.
Android companion to https://invent.kde.org/kde/kdeconnect-kde/merge_requests/97
Currently there are several rough areas:
- Multi-target messages do not have the full list of recipients (I am planning to work on this in another patch, because this one is already quite large enough)
- Parsing MMS is significantly slower than parsing SMS. This makes sense, since we need to make significantly many more content:// calls for MMS. The only solution I can think of here is to add the ability to request a range of messages, which I need to do anyway, but which should not be part of this patch.
- The desktop app is totally busted with regard to multi-target MMS, but that will also be fixed in another MR
BUG: 398889
## Test Plan
### Before:
Open SMS app on desktop, scroll through conversations, notice:
- Any single-target message which had the most-recent message as an MMS does not appear
- Any multi-target MMS conversations do not appear
### After:
Open SMS app on desktop, notice:
- Conversations which have an MMS as their most-recent message appear
- MMS which consisted of only text are rendered correctly
- Multi-target conversations are shown (though pretty busted, as said before. Do not attempt to reply to one!)
This would happen to people who transferred their KDE Connect config from
one phone to another (mostly with backup apps that only work on rooted
phones). This led to a state where other devices would always reject the
connection because the certificate CN didn't match the device ID.
On the PC side this is not a problem because the certificate is the source
of truth for the device ID.
Summary:
So from android 8 onwards it appears that fetching content from "cleartext" urls is disabled by default
https://stackoverflow.com/questions/45940861/android-8-cleartext-http-traffic-not-permitted
I have a mpris service running on my local computer which is connected to the android, that service is also serving cover art for currently playing song. Obviously I can not have a domain set for my computer on a local machine, so cover art urls look like
`http://<ip>:<port>/<songid>.ext` . Since this restriction was introduced into android 8, kde connect is not able to fetch the art from this url.
This is patch allows connections to raw IPs addresses as well. If there is any security issues regarding this change, I'm prepared to do more work, my suggestion would be to check if IP address in this case matches paired computer's IP address, although this would still be a bit annoying (especially since whatever malicious file can be served from a "cleartext" link as well).
Test Plan:
- start some sort of server which can serve an image on a paired computer
- create mpris Player instance on a paired computer and set the `mpris:artUrl` to the served address where this image is available
- open kde connect android app, select prepared player and see default cover art instead of the served image
- change artUrl to some image from the web
- check in kde connect again and see it correctly show a remote image
Reviewers: #kde_connect, nicolasfella, albertvaka
Reviewed By: #kde_connect, nicolasfella, albertvaka
Subscribers: albertvaka, nicolasfella, andyholmes, kdeconnect
Tags: #kde_connect
Differential Revision: https://phabricator.kde.org/D21247
android:requestLegacyExternalStorage="true"><!-- requestLegacyExternalStorage is only used in Android 10: https://developer.android.com/training/data-storage/use-cases#opt-out-in-production-app -->
<!-- TODO: Remove? This is only used by https://github.com/andOTP/andOTP, which is unmaintained since 2021. Do people use forks or can we remove this? -->
@@ -9,21 +9,29 @@ KDE Connect is a multi-platform app that allows your devices to communicate (eg:
- **Multimedia remote control**: Use your phone as a remote for Linux media players.
- **Virtual touchpad**: Use your phone screen as your computer's touchpad and keyboard.
All this without wires, over the already existing WiFi network, and using TLS encryption.
All this without wires, over the already existing Wi-Fi network, and using TLS encryption.
## About this app
This is a native Android port of the KDE Connect Qt app. You will find a more complete readme about KDE Connect [here](https://github.com/KDE/kdeconnect-kde).
This is a native Android port of the KDE Connect Qt app. You will find a more complete readme about KDE Connect [here](https://invent.kde.org/network/kdeconnect-kde/).
## How to install this app
You can install this app from the [Play Store](https://play.google.com/store/apps/details?id=org.kde.kdeconnect_tp) as well as [F-Droid](https://f-droid.org/repository/browse/?fdid=org.kde.kdeconnect_tp). Note you will also need to install the [desktop app](https://github.com/KDE/kdeconnect-kde) for it to work.
You can install this app from the [Play Store](https://play.google.com/store/apps/details?id=org.kde.kdeconnect_tp) as well as [F-Droid](https://f-droid.org/repository/browse/?fdid=org.kde.kdeconnect_tp). Note you will also need to install the [desktop app](https://invent.kde.org/network/kdeconnect-kde) for it to work.
## Contributing
To contribute patches, use [KDE Connect's Phabricator](https://phabricator.kde.org/project/profile/159/). There you can also find a task list with stuff to do, and links to other relevant resources. It is a good idea to also subscribe to the [KDE Connect mailing list](https://mail.kde.org/mailman/listinfo/kdeconnect).
A lot of useful information, including how to get started working on KDE Connect and how to connect with the current developers, is on our [KDE Community Wiki page](https://community.kde.org/KDEConnect)
For bug reporting, please use [KDE's Bugzilla](https://bugs.kde.org). Please do not use the issue tracker in GitLab since we want to keep everything in one place.
To contribute patches, use [KDE Connect's Gitlab](https://invent.kde.org/network/kdeconnect-android/).
On Gitlab (as well as on our [old Phabricator](https://phabricator.kde.org/tag/kde_connect/)) you can find a task list with stuff to do and links to other relevant resources.
It is a good idea to also subscribe to the [KDE Connect mailing list](https://mail.kde.org/mailman/listinfo/kdeconnect).
Please know that all translations for all KDE apps are handled by the [localization team](https://l10n.kde.org/). If you would like to submit a translation, that should be done by working with the proper team for that language.
## License
[GNU GPL v2](https://www.gnu.org/licenses/gpl-2.0.html) and [GNU GPL v3](https://www.gnu.org/licenses/gpl-3.0.html)
If you are reading this from Github, you should know that this is just a mirror of the [KDE Project repo](https://projects.kde.org/projects/extragear/network/kdeconnect-android/repository/).
If you are reading this from GitHub, you should know that this is just a mirror of the [KDE Project repo](https://invent.kde.org/network/kdeconnect-android/).
يوفر جسر كِيدِي مجموعة من الميزات لدمج سير عملك عبر الأجهزة:
- نقل الملفات بين أجهزتك.
- الوصول إلى الملفات الموجودة على هاتفك من حاسوبك، دون أسلاك.
- الحافظة المشتركة: النسخ واللصق بين أجهزتك.
- الحصول على إشعارات للمكالمات والرسائل الواردة على حاسوبك.
- لوحة اللمس افتراضية: استخدم شاشة هاتفك كلوحة لمس لحاسوبك.
- مزامنة الإشعارات: الوصول إلى إشعارات هاتفك من حاسوبك والرد على الرسائل.
- التحكم عن بعد في الوسائط المتعددة: استخدم هاتفك كجهاز تحكم عن بعد لمشغلات الوسائط لينكس.
- اتصال واي فاي: لا حاجة إلى سلك يو اس بي أو بلوتوث.
- تعمية TLS من البداية إلى النهاية: معلوماتك آمنة.
يرجى ملاحظة أنك ستحتاج إلى تثبيت جسر كِيدِي على حاسوبك حتى يعمل هذا التطبيق، والحفاظ على تحديث إصدار سطح المكتب بإصدار أندوريد حتى تعمل أحدث الميزات.
معلومات الأذونات الحساسة:
* إذن إمكانية الوصول: مطلوب لتلقي إدخال من جهاز آخر للتحكم في هاتف أندرويد خاص بك، إذا كنت تستخدم ميزة الإدخال عن بُعد.
* إذن تحديد الموقع في الخلفية: مطلوب لمعرفة شبكة واي فاي التي تتصل بها، إذا كنت تستخدم ميزة الشبكات الموثوقة.
لا يرسل جسر كِيدِي أي معلومات إلى كيدي أو إلى أي طرف ثالث. يرسل جسر كِيدِي البيانات من جهاز إلى آخر مباشرةً باستخدام الشبكة المحلية، وليس عبر الإنترنت، وباستخدام التعمية من البداية إلى النهاية.
هذا التطبيق جزء من مشروع مفتوح المصدر وهو موجود بفضل جميع الأشخاص الذين ساهموا فيه. زر الموقع الإلكتروني للحصول على الشفرة المصدرية.
Nəzərə alın ki, bu tətbiqin işləməsi üçün kompyuterinizə KDE Connect-i quraşdırmalısınız və sonuncu funksiyaların işləməsi üçün masaüstü və Android versiyalarını sonuncu versiyaya eyni şəkildə yeniləməlisiniz.
Həssas icazələr haqqında məlumat:
*Giriş imkanı icazələri: Əgər uzaqdan daxiletmə funksiyasından istifadə edirsinizsə Android cihazınızı idarə etmək üçün başqa cihazlardan daxil olanları qəbul etmək tələb olunur.
*Məkanın arxa fonda istifadəsinə icazə: Əgər etibarlı şəbəkə funksiyasından
istifadə edirsinizsə hansı WiFi şəbəkəsinə qoşulduğunuzu bilməniz tələb olunur
KDE Connect heç bir halda məlumatları KDE-yə və ya üçüncü tərəfə ötürmür. KDE Connect məlumatları bir cihazdan başqasına internet istifadə etmədən və ucdan-uca şifrələmədən istifadə edərək yerli şəbəkə üzərindən göndərir.
Bu tətbiq açıq qaynaq layihəsinin bir hissəsidir və ona töhvə verənlərin sayəsində mövcuddur. Mənbə kodunu əldə etmək üçün veb-səhifəyə daxil olun.
KDE Connect предоставя набор от функции за интегриране на вашия работен процес на различни устройства:
- Прехвърляйте файлове между вашите устройства.
- Осъществявайте достъп до файлове на телефона си от компютъра си, без кабели.
- Споделен клипборд: копирайте и поставяйте между вашите устройства.
- Получавайте известия за входящи обаждания и съобщения на вашия компютър.
- Виртуален тъчпад: Използвайте екрана на телефона си като тъчпад на компютъра.
- Синхронизиране на известия: Достъп до известията на телефона ви от вашия компютър и отговаряне на съобщения.
- Мултимедийно дистанционно управление: Използвайте телефона си като дистанционно за Linux медийни плейъри.
- WiFi връзка: не е необходим USB кабел или bluetooth.
- TLS криптиране от край до край: информацията ви е в безопасност.
Моля, имайте предвид, че ще трябва да инсталирате KDE Connect на вашия компютър, за да работи това приложение, и поддържайте версията за настолен компютър актуална с версията за Android, за да работят най-новите функции.
Поверителна информация за разрешения:
* Разрешение за достъпност: Изисква се за получаване на вход от друго устройство за управление на вашия телефон с Android, ако използвате функцията за отдалечено въвеждане.
* Разрешение за местоположение във фонов режим: Изисква се, за да знаете към коя WiFi мрежа сте свързани, ако използвате функцията Trusted Networks.
KDE Connect никога не изпраща никаква информация на KDE или на трета страна. KDE Connect изпраща данни от едно устройство на друго директно чрез локалната мрежа, никога през интернет, и чрез криптиране от край до край.
Това приложение е част от проект с отворен код и съществува благодарение на всички хора, които са допринесли за него. Посетете уебсайта, за да вземете изходния код.
El KDE Connect proporciona un conjunt de característiques per a integrar el flux de treball entre dispositius:
- Transferiu fitxers entre els vostres dispositius.
- Accediu als fitxers del telèfon mòbil des de l'ordinador, sense cables.
- Porta-retalls compartit: copieu i enganxeu entre els dispositius.
- Obteniu les notificacions de trucades entrants i missatges a l'ordinador.
- Ratolí tàctil virtual: utilitzeu la pantalla del telèfon com a ratolí tàctil de l'ordinador.
- Sincronització de notificacions: accediu a les notificacions del telèfon des de l'ordinador i contesteu els missatges.
- Control remot multimèdia: utilitzeu el telèfon com a control remot dels reproductors multimèdia Linux.
- Connexió Wi-Fi: no cal connexió USB ni Bluetooth.
- Encriptatge TLS d'extrem a extrem: la informació és segura.
Tingueu en compte que haureu d'instal·lar el KDE Connect a l'ordinador perquè aquesta aplicació funcioni, i mantingueu actualitzada la versió d'escriptori amb la versió de l'Android perquè funcionin les últimes característiques.
Informació dels permisos confidencials:
* Permís d'accessibilitat: requerit per a rebre l'entrada des d'un altre dispositiu per a controlar el telèfon Android, si utilitzeu la característica d'entrada remota.
* Permís d'ubicació en segon pla: requerit per a saber a quina xarxa Wi-Fi esteu connectat, si utilitzeu la característica xarxes de confiança.
El KDE Connect mai envia cap informació a KDE ni a cap tercer. El KDE Connect envia dades des d'un dispositiu a l'altre directament utilitzant la xarxa local, mai a través d'Internet, i utilitzant l'encriptatge d'extrem a extrem.
Aquesta aplicació forma part d'un projecte de codi obert i existeix gràcies a totes les persones que hi han contribuït. Visiteu el lloc web per a aconseguir el codi font.
KDE Connect poskytuje sadu vlastností pro vzájemnou integraci vašich zařízení:
- Přenášejte soubory mezi zařízeními.
- Přistupujte bezdrátově k souborům na vašem počítači
- Sdílená schránka: kopírujte a vkládejte z jednoho zařízení na druhé.
- Přijímejte upozornění na příchozí hovory nebo SMS na vašem PC.
- Virtuální touchpad: Používejte obrazovku svého telefonu jako touchpad počítače.
- Synchronizace upozornění: Čtěte upozornění z vašeho telefonu na počítači.
- Vzdálené ovládání multimédií: Používejte svůj telefon jako ovladač přehrávače na Linuxu.
- Připojení WiFi: Není potřeba kabel USB ani Bluetooth.
- Koncové šifrování TLS: Vaše informace jsou v bezpečí.
Prosím pamatujte, že pro správnou funkci této aplikace je nutné abyste na vašem počítači měli nainstalován KDE Connect a udržovali jej aktuální na počítači i na Androidu.
Informace o citlivých oprávněních:
* Oprávnění přístupnosti: Nutné pro příjem vstupu z jiného zařízení aby mohlo ovládat váš telefon Android pokud používáte vlastnost Vzdálený vstup.
* Oprávnění o poloze na pozadí: Je potřebné pro rozpoznání, ke které síti WiFi jste připojeni, pokud používáte funkci Důvěryhodné sítě.
KDE Connect nikdy neposílá KDE ani nikomu jinému jakékoliv informace. KDE Connect odesílá data z jednoho zařízení druhému přímo přes místní síť, nikdy přes internet, a výhradně s použitím koncového šifrování.
Tato aplikace je součástí Open Source projektu a existuje jenom díky přispěvatelům. Zdrojové soubory naleznete na webových stránkách.
KDE Connect bietet eine Reihe von Funktionen, um Ihre Arbeitsabläufe über verschiedene Geräte zu vereinigen:
- Daten zwischen Ihren Geräten übertragen.
- Auf Daten auf Ihrem Telefon von Ihrem Computer aus zugreifen, ohne Kabel.
- Geteilte Zwischenablage: Kopieren und Einfügen zwischen Ihren Geräten.
- Erhalten Sie Benachrichtigungen über eingehende Anrufe und Nachrichten auf Ihren Computer.
- Virtuelles Touchpad: Verwenden Sie den Bildschirm Ihres Telefons als Touchpad für Ihren Computer.
- Abgleich der Benachrichtigungen: Greifen Sie über den Computer auf Ihre Telefonbenachrichtigungen zu und antworten Sie auf Nachrichten.
- Multimedia-Fernbedienung: Verwenden Sie Ihr Telefon als Fernbedienung für Linux-Medienspieler.
- WLAN-Verbindung: kein USB-Kabel oder Bluetooth erforderlich.
- Ende-zu-Ende-TLS-Verschlüsselung: Ihre Informationen sind sicher.
Bitte beachten Sie, dass Sie KDE Connect auf Ihrem Computer installieren müssen, damit diese App funktioniert und halten Sie die Desktop-Version mit der Android-Version auf dem aktuellen Stand, um die neuesten Funktionen nutzen zu können.
Informationen zu sensiblen Berechtigungen:
* Zugriffsberechtigung: Wird benötigt, um Eingaben zur Steuerung ihres Android-Telefons von einem anderen Gerät zu erhalten, wenn Sie die Ferneingabefunktion verwenden.
* Berechtigung den Standort im Hintergrund zu nutzen: Wird benötigt, um festzustellen, mit welchem WLAN-Netzwerk Sie verbunden sind, wenn Sie die Funktion „Vertrauenswürdige Netzwerke” verwenden.
KDE Connect sendet niemals irgendwelche Informationen an KDE oder an Dritte. KDE Connect sendet Daten, unter Verwendung einer Ende-zu-Ende-Verschlüsselung, über das lokale Netzwerk direkt von einem Gerät zum anderen, niemals über das Internet.
Diese App ist Teil eines Open-Scource-Projekts und besteht Dank all der Menschen die dazu beigetragen haben. Besuchen Sie die Internetseite, um sich den Quelltext zu holen.
KDE Connect provides a set of features to integrate your workflow across devices:
- Transfer files between your devices.
- Access files on your phone from your computer, without wires.
- Shared clipboard: copy and paste between your devices.
- Get notifications for incoming calls and messages on your computer.
- Virtual touchpad: Use your phone screen as your computer's touchpad.
- Notifications sync: Access your phone notifications from your computer and reply to messages.
- Multimedia remote control: Use your phone as a remote for Linux media players.
- WiFi connection: no USB wire or bluetooth needed.
- End-to-end TLS encryption: your information is safe.
Please note you will need to install KDE Connect on your computer for this app to work, and keep the desktop version up-to-date with the Android version for the latest features to work.
Sensitive permissions information:
* Accessibility permission: Required to receive input from another device to control your Android phone, if you use the Remote Input feature.
* Background location permission: Required to know to which WiFi network you are connected to, if you use the Trusted Networks feature.
KDE Connect never sends any information to KDE nor to any third party. KDE Connect sends data from one device to the other directly using the local network, never through the internet, and using end to end encryption.
This app is part of an open source project and it exists thanks to all the people who contributed to it. Visit the website to grab the source code.
KDE Connect provides a set of features to integrate your workflow across devices:
- Transfer files between your devices.
- Access files on your phone from your computer, without wires.
- Shared clipboard: copy and paste between your devices.
- Get notifications for incoming calls and messages on your computer.
- Virtual touchpad: Use your phone screen as your computer's touchpad.
- Notifications sync: Access your phone notifications from your computer and reply to messages.
- Multimedia remote control: Use your phone as a remote for Linux media players.
- WiFi connection: no USB wire or bluetooth needed.
- End-to-end TLS encryption: your information is safe.
Please note you will need to install KDE Connect on your computer for this app to work, and keep the desktop version up-to-date with the Android version for the latest features to work.
Sensitive permissions information:
* Accessibility permission: Required to receive input from another device to control your Android phone, if you use the Remote Input feature.
* Background location permission: Required to know to which WiFi network you are connected to, if you use the Trusted Networks feature.
KDE Connect never sends any information to KDE nor to any third party. KDE Connect sends data from one device to the other directly using the local network, never through the internet, and using end to end encryption.
This app is part of an open source project and it exists thanks to all the people who contributed to it. Visit the website to grab the source code.
KDE Connect proporciona una serie de funcionalidades para integrar tus flujos de trabajo entre distintos dispositivos:
- Transferir archivos entre dispositivos.
- Acceder a archivos en tu teléfono desde tu equipo, sin cables.
- Portapapeles compartido: copia y pega entre tus dispositivos.
- Recibe notificaciones de llamadas entrantes y mensajes en tu equipo.
- Panel táctil virtual: Usa la pantalla de tu teléfono como panel táctil de tu equipo.
- Sincronización de notificaciones: Accede a las notificaciones de tu teléfono desde tu equipo y responde mensajes .
- Control remoto multimedia: Usa tu teléfono como mando a distancia de tus reproductores multimedia Linux.
- Conexión WiFi: no se necesitan cables USB o Bluetooth.
- Cifrado TLS extremo a extremo: tu información está a salvo.
Ten en cuenta que necesitas tener instalado KDE en tu equipo para que esta aplicación funcione, y mantener la versión de escritorio actualizada con la versión de Android para tener acceso a las nuevas funcionalidades.
Información de permisos:
* Permisos de acceso: Necesarios para recibir entradas desde otro dispositivo para controlar su dispositivo Android, si usa la funcionalidad de entrada remota.
* Permisos de localización en segundo plano: Necesarios para saber a que red WiFi está conectado, si usa la funcionalidad de redes confiables.
KDE Connect nunca envía ninguna información a KDE o a terceros. KDE Connect envía datos de un dispositivo a otro usando directamente la red local, nunca a través de internet, y usando cifrado extremo a extremo.
Esta aplicación es parte de un proyecto de código abierto y existe gracias a toda gente que ha contribuido a ella. Visita la página web para acceder al código fuente.
«KDE Connect»ek zure lan-fluxua gailuen artean bateratzeko ezaugarri multzo bat eskaintzen du:
- Zure gailuen arteko fitxategi transferentziak.
- Atzitu zure telefonoko fitxategiak zure ordenagailutik, haririk gabe.
- Arbela partekatua: Gailu batetik bestera kopiatu eta itsatsi.
- Jaso zure ordenagailuan sarrerako deien eta mezuen jakinarazpenak.
- Alegiazko ukimen-sagua: Erabili zure telefonoaren pantaila zure ordenagailuaren ukimen-sagu gisa.
- Jakinarazpenak sinkronizatzea: Atzitu zure telefonoko jakinarazpenak zure ordenagailutik eta erantzun mezuei.
- Multimediaren urrutiko agintea: Erabili zure telefonoa Linuxeko euskarri jotzaileen urrutiko aginte gisa.
- Wi-Fi konexioa: Ez da USB kablerik edo bluetooth-ik behar.
- Muturren arteko TLS zifratzea: Zure informazioa seguru dago.
Kontuan izan, aplikazio hau ibil dadin KDE Connect zure ordenagailuan instalatu beharko duzula, eta mahaigaineko bertsioa Androideko bertsioarekin eguneratuta mantendu beharko duzula ezaugarri berrienak ibil daitezen.
Babes bereziko baimenei buruzko informazioa:
* Irisgarritasun baimena: Beharrezkoa zure Android telefonoa kontrolatzeko beste gailu baten sarrera jasotzeko, urrutiko sarrera ezaugarria erabiltzen baduzu.
* Atzeko planoko kokapen baimena: Beharrezkoa zein Wi-Fi sarera konektatuta zauden jakiteko, Konfiantzazko sareen ezaugarria erabiltzen baduzu.
«KDE Connect»ek ez dio sekula KDEri edo beste inori informaziorik bidaltzen. «KDE Connect»ek datuak gailu batetik beste batera zuzenean bidaltzen ditu sare lokala erabiliz, sekula ez Internet bidez, eta betiere muturren artean zifratuta.
Aplikazio hau sorburu irekiko proiektu baten zati da, eta horretan lagundu duten lagun guztiei esker existitzen da. Bisitatu webgunea sorburu-kodea hartzeko.
– Langaton verkkoyhteys: USB-johtoa tai Bluetoothia ei tarvita.
– TLS-salaus päästä päähän: tietosi ovat turvassa.
Huomaa, että jotta sovellus kaikkine ominaisuuksineen toimisi, KDE Connect tulee asentaa tietokoneeseen ja pitää ajan tasalla Android-version kanssa.
Tietoa arkaluontoisista käyttöoikeuksista:
– Saavutettavuuskäyttöoikeus: vaaditaan, jotta toisen laitteen syötteellä voisi hallita Android-puhelinta (jos käytetään etäsyöttöominaisuutta).
– Sijaintitiedon käyttöoikeus taustalla: vaaditaan, jotta tiedetään, mihin verkkoon on yhdistetty (jos käytetään luotettujen verkkojen ominaisuutta).
KDE Connect ei koskaan lähetä tietoa KDE:lle tai kolmansille osapuolille. Tieto lähetetään suoraan laitteesta toiseen paikallisverkossa, ei koskaan internetissä, ja käytössä on salaus päästä päähän.
Sovellus on avoimen lähdekoodin projekti ja on olemassa sitä avustaneiden ihmisten ansiosta. Lähdekoodin saat noudettua kotisivulta.
KDEConnect fournit un ensemble de fonctionnalités pour intégrer votre flux de travail entre périphériques:
- Transfert des fichiers entre vos périphériques.
- Accès aux fichiers sur votre téléphone depuis votre ordinateur, sans fil.
- Presse-papier partagé: copier et coller entre vos périphériques.
- Apparition de notifications pour les appels et les messages entrants sur votre ordinateur.
- Pavé tactile virtuel: utilisation de l'écran de votre téléphone comme pavé tactile pour votre ordinateur.
- Synchronisation de vos notifications: accès à vos notifications téléphoniques depuis votre ordinateur et réponses aux messages.
- Télé-commande multimédia: utilisation de votre téléphone comme télécommande pour les lecteurs de média sous Linux.
- Connexion au Wifi: aucun connexion USB ou Bluetooth nécessaire.
- Chiffrement «TLS» de bout en bout: vos informations sont en sécurité.
Veuillez noter que vous devrez installer KDEConnect sur votre ordinateur pour que cette application fonctionne et maintenir la version de bureau à jour avec la version Android pour les dernières fonctionnalités.
Informations sur les permissions sensibles:
* Permission d'accessibilité: nécessaire pour recevoir les informations d'un autre périphérique pour contrôler votre téléphone Android, si vous utilisez la fonction de télécommande.
* Permission pour emplacement en arrière-plan: nécessaire pour savoir à quel réseau Wifi auquel vous êtes connecté, si vous utilisez la fonctionnalité de réseaux de confiance.
KDEConnect n'envoie jamais d'informations à KDE ni à aucun tiers. KDEConnect envoie des données d'un périphérique à un autre à l'aide du réseau local, mais jamais par Internet et en utilisant le chiffrement de bout en bout.
Cette application fait partie d'un projet «Open source». Il existe grâce à toutes les personnes qui y ont contribué. Veuillez visiter le site Internet pour accéder au code source.
KDE Connect fornece funcionalidades para facilitar traballar con varios dispositivos:
• Transferir ficheiros entre dispositivos.
• Acceder a ficheiros do teléfono desde o computador, sen cables.
• Portapapeis compartido: copie e pegue entre dispositivos.
• Obter notificacións de chamadas e mensaxes no computador.
• Panel táctil virtual: use a pantalla do teléfono como panel táctil do computador.
• Sincronización de notificacións: lea as notificacións do teléfono desde o computador e responda a mensaxes.
• Mando a distancia multimedia: use o teléfono como mando a distancia para reprodutores multimedia de Linux.
• Conexión WiFi: non necesita cable USB nin Bluetooth.
• Cifrado TLS de extremo a extremo: a súa información está segura.
Para que esta aplicación funcione ten que instalar KDE Connect no computador, e manter a versión do computador e de Android actualizadas para que funcionen as últimas funcionalidades.
Permisos de información persoal:
• Permiso de accesibilidade: necesario para recibir entrada doutro dispositivo para controlar o teléfono Android, se usa a funcionalidade de entrada remota.
• Permiso de localización en segundo plano: necesario para saber con que rede WiFi ten conexión, se usa a funcionalidade de redes de confianza.
KDE Connect nunca envía información a KDE nin a terceiras partes. KDE Connect envía os datos dun dispositivo a outro directamente pola rede local, nunca a través de Internet, e usando cifraxe de extremo a extremo.
Esta aplicación é parte dun proxecto de software libre e existe grazas á xente que colaborou no proxecto. Visite o sitio web para obter o código fonte.
KDE Connect fornisce una serie di funzionalità per integrare il tuo flusso di lavoro su tutti i dispositivi:
- Trasferisci file tra i tuoi dispositivi.
- Accedi ai file sul tuo telefono dal tuo computer, senza cavi.
- Appunti condivisi: copia e incolla tra i tuoi dispositivi.
- Condividi file e URL sul tuo computer da qualsiasi applicazione.
- Ricevi notifiche per chiamate in arrivo e messaggi SMS sul tuo computer.
- Touchpad virtuale: utilizza lo schermo del telefono come touchpad del computer.
- Sincronizzazione delle notifiche: leggi le notifiche Android dal desktop.
- Telecomando multimediale: usa il tuo telefono come telecomando per i lettori multimediali per Linux.
- Connessione WiFi: non necessita di alcun cavo USB o bluetooth.
- Cifratura TLS end-to-end: le tue informazioni sono al sicuro.
Tieni presente che dovrai installare KDE Connect sul tuo computer affinché questa applicazione funzioni e mantenere la versione desktop aggiornata con la versione Android affinché funzionino le funzionalità più recenti.
Informazioni sensibili sui permessi:
* Permesso di accessibilità: necessario per ricevere input da un altro dispositivo per controllare il tuo telefono Android, se utilizzi la funzione di immissione remota.
* Permesso alla posizione in background: necessario per sapere a quale rete WiFi sei collegato, se utilizzi la funzionalità Reti affidabili.
KDE Connect non invia mai alcuna informazione a KDE né a terze parti. KDE Connect invia i dati da un dispositivo all'altro direttamente utilizzando la rete locale, mai attraverso Internet, e utilizzando la cifratura end-to-end.
Questa applicazione fa parte di un progetto open source ed esiste grazie a tutte le persone che vi hanno contribuito. Visita il sito web per ottenere il codice sorgente.
Some files were not shown because too many files have changed in this diff
Show More
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.