mir/kdeconnect-android
2
0
Fork 0
mirror of https://github.com/KDE/kdeconnect-android synced 2025-08-22 09:58:08 +00:00
Code Issues Releases Wiki Activity

Add DeviceInfo class

Browse Source 
`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.
This commit is contained in:
Albert Vaca Cintora 2023-06-27 11:14:36 +00:00
parent 310e61b570
commit 8c1603f6e4
18 changed files with 371 additions and 286 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/org/kde/kdeconnect/Backends/BaseLink.java
View File

@ -12,6 +12,7 @@ import androidx.annotation.NonNull;
import androidx.annotation.WorkerThread;
import org.kde.kdeconnect.Device;
import org.kde.kdeconnect.DeviceInfo;
import org.kde.kdeconnect.NetworkPacket;
import java.io.IOException;
@ -26,20 +27,20 @@ public abstract class BaseLink {
protected final Context context;
private final BaseLinkProvider linkProvider;
private final String deviceId;
private final ArrayList<PacketReceiver> receivers = new ArrayList<>();
protected BaseLink(@NonNull Context context, @NonNull String deviceId, @NonNull BaseLinkProvider linkProvider) {
protected BaseLink(@NonNull Context context, @NonNull BaseLinkProvider linkProvider) {
this.context = context;
this.linkProvider = linkProvider;
this.deviceId = deviceId;
}
/* To be implemented by each link for pairing handlers */
public abstract String getName();
public abstract DeviceInfo getDeviceInfo();
public String getDeviceId() {
return deviceId;
return getDeviceInfo().id;
}
public BaseLinkProvider getLinkProvider() {
@ -54,7 +55,7 @@ public abstract class BaseLink {
}
//Should be called from a background thread listening for packets
protected void packetReceived(@NonNull NetworkPacket np) {
public void packetReceived(@NonNull NetworkPacket np) {
for(PacketReceiver pr : receivers) {
pr.onPacketReceived(np);
}

19
src/org/kde/kdeconnect/Backends/BaseLinkProvider.java
View File

@ -8,23 +8,17 @@ package org.kde.kdeconnect.Backends;
import androidx.annotation.NonNull;
import org.kde.kdeconnect.NetworkPacket;
import java.security.cert.Certificate;
import java.util.concurrent.CopyOnWriteArrayList;
public abstract class BaseLinkProvider {
private final CopyOnWriteArrayList<ConnectionReceiver> connectionReceivers = new CopyOnWriteArrayList<>();
public interface ConnectionReceiver {
void onConnectionReceived(@NonNull final String deviceId,
@NonNull final Certificate certificate,
@NonNull final NetworkPacket identityPacket,
@NonNull final BaseLink link);
void onConnectionReceived(@NonNull final BaseLink link);
void onConnectionLost(BaseLink link);
}
private final CopyOnWriteArrayList<ConnectionReceiver> connectionReceivers = new CopyOnWriteArrayList<>();
public void addConnectionReceiver(ConnectionReceiver cr) {
connectionReceivers.add(cr);
}
@ -36,13 +30,10 @@ public abstract class BaseLinkProvider {
/**
* To be called from the child classes when a link to a new device is established
*/
protected void onConnectionReceived(@NonNull final String deviceId,
@NonNull final Certificate certificate,
@NonNull final NetworkPacket identityPacket,
@NonNull final BaseLink link) {
protected void onConnectionReceived(@NonNull final BaseLink link) {
//Log.i("KDE/LinkProvider", "onConnectionReceived");
for(ConnectionReceiver cr : connectionReceivers) {
cr.onConnectionReceived(deviceId, certificate, identityPacket, link);
cr.onConnectionReceived(link);
}
}

14
src/org/kde/kdeconnect/Backends/BluetoothBackend/BluetoothLink.java
View File

@ -17,6 +17,7 @@ import org.json.JSONException;
import org.json.JSONObject;
import org.kde.kdeconnect.Backends.BaseLink;
import org.kde.kdeconnect.Device;
import org.kde.kdeconnect.DeviceInfo;
import org.kde.kdeconnect.NetworkPacket;
import java.io.IOException;
@ -34,6 +35,7 @@ public class BluetoothLink extends BaseLink {
private final OutputStream output;
private final BluetoothDevice remoteAddress;
private final BluetoothLinkProvider linkProvider;
private final DeviceInfo deviceInfo;
private boolean continueAccepting = true;
@ -93,11 +95,12 @@ public class BluetoothLink extends BaseLink {
}
});
public BluetoothLink(Context context, ConnectionMultiplexer connection, InputStream input, OutputStream output, BluetoothDevice remoteAddress, String deviceId, BluetoothLinkProvider linkProvider) {
super(context, deviceId, linkProvider);
public BluetoothLink(Context context, ConnectionMultiplexer connection, InputStream input, OutputStream output, BluetoothDevice remoteAddress, DeviceInfo deviceInfo, BluetoothLinkProvider linkProvider) {
super(context, linkProvider);
this.connection = connection;
this.input = input;
this.output = output;
this.deviceInfo = deviceInfo;
this.remoteAddress = remoteAddress;
this.linkProvider = linkProvider;
}
@ -111,6 +114,11 @@ public class BluetoothLink extends BaseLink {
return "BluetoothLink";
}
@Override
public DeviceInfo getDeviceInfo() {
return deviceInfo;
}
public void disconnect() {
if (connection == null) {
return;
@ -120,7 +128,7 @@ public class BluetoothLink extends BaseLink {
connection.close();
} catch (IOException ignored) {
}
linkProvider.disconnectedLink(this, getDeviceId(), remoteAddress);
linkProvider.disconnectedLink(this, remoteAddress);
}
private void sendMessage(NetworkPacket np) throws JSONException, IOException {

41
src/org/kde/kdeconnect/Backends/BluetoothBackend/BluetoothLinkProvider.java
View File

@ -20,6 +20,8 @@ import android.util.Log;
import org.kde.kdeconnect.Backends.BaseLinkProvider;
import org.kde.kdeconnect.Device;
import org.kde.kdeconnect.DeviceInfo;
import org.kde.kdeconnect.Helpers.DeviceHelper;
import org.kde.kdeconnect.Helpers.SecurityHelpers.SslHelper;
import org.kde.kdeconnect.Helpers.ThreadHelper;
import org.kde.kdeconnect.NetworkPacket;
@ -54,10 +56,6 @@ public class BluetoothLinkProvider extends BaseLinkProvider {
private void addLink(NetworkPacket identityPacket, BluetoothLink link) throws CertificateException {
String deviceId = identityPacket.getString("deviceId");
String certificateString = identityPacket.getString("certificate");
byte[] certificateBytes = Base64.decode(certificateString, 0);
Certificate certificate = SslHelper.parseCertificate(certificateBytes);
Log.i("BluetoothLinkProvider", "addLink to " + deviceId);
BluetoothLink oldLink = visibleDevices.get(deviceId);
if (oldLink == link) {
@ -65,8 +63,9 @@ public class BluetoothLinkProvider extends BaseLinkProvider {
return;
}
visibleDevices.put(deviceId, link);
onConnectionReceived(deviceId, certificate, identityPacket, link);
onConnectionReceived(link);
link.startListening();
link.packetReceived(identityPacket);
if (oldLink != null) {
Log.i("BluetoothLinkProvider", "Removing old connection to same device");
oldLink.disconnect();
@ -127,9 +126,9 @@ public class BluetoothLinkProvider extends BaseLinkProvider {
return "BluetoothLinkProvider";
}
public void disconnectedLink(BluetoothLink link, String deviceId, BluetoothDevice remoteAddress) {
public void disconnectedLink(BluetoothLink link, BluetoothDevice remoteAddress) {
sockets.remove(remoteAddress);
visibleDevices.remove(deviceId);
visibleDevices.remove(link.getDeviceId());
onConnectionLost(link);
}
@ -196,8 +195,10 @@ public class BluetoothLinkProvider extends BaseLinkProvider {
OutputStream outputStream = connection.getDefaultOutputStream();
InputStream inputStream = connection.getDefaultInputStream();
NetworkPacket np = NetworkPacket.createIdentityPacket(context);
DeviceInfo myDeviceInfo = DeviceHelper.getDeviceInfo(context);
NetworkPacket np = myDeviceInfo.toIdentityPacket();
np.set("certificate", Base64.encodeToString(SslHelper.certificate.getEncoded(), 0));
byte[] message = np.serialize().getBytes(Charsets.UTF_8);
outputStream.write(message);
outputStream.flush();
@ -223,9 +224,15 @@ public class BluetoothLinkProvider extends BaseLinkProvider {
Log.i("BTLinkProvider/Server", "Received identity packet");
String certificateString = identityPacket.getString("certificate");
byte[] certificateBytes = Base64.decode(certificateString, 0);
Certificate certificate = SslHelper.parseCertificate(certificateBytes);
DeviceInfo deviceInfo = DeviceInfo.fromIdentityPacketAndCert(identityPacket, certificate);
BluetoothLink link = new BluetoothLink(context, connection,
inputStream, outputStream, socket.getRemoteDevice(),
identityPacket.getString("deviceId"), BluetoothLinkProvider.this);
deviceInfo, BluetoothLinkProvider.this);
addLink(identityPacket, link);
} catch (Exception e) {
synchronized (sockets) {
@ -360,7 +367,7 @@ public class BluetoothLinkProvider extends BaseLinkProvider {
Log.i("BTLinkProvider/Client", "Received identity packet");
String myId = NetworkPacket.createIdentityPacket(context).getString("deviceId");
String myId = DeviceHelper.getDeviceId(context);
if (identityPacket.getString("deviceId").equals(myId)) {
// Probably won't happen, but just to be safe
connection.close();
@ -373,10 +380,18 @@ public class BluetoothLinkProvider extends BaseLinkProvider {
Log.i("BTLinkProvider/Client", "identity packet received, creating link");
final BluetoothLink link = new BluetoothLink(context, connection, inputStream, outputStream,
socket.getRemoteDevice(), identityPacket.getString("deviceId"), BluetoothLinkProvider.this);
String certificateString = identityPacket.getString("certificate");
byte[] certificateBytes = Base64.decode(certificateString, 0);
Certificate certificate = SslHelper.parseCertificate(certificateBytes);
DeviceInfo deviceInfo = DeviceInfo.fromIdentityPacketAndCert(identityPacket, certificate);
final BluetoothLink link = new BluetoothLink(context, connection, inputStream, outputStream,
socket.getRemoteDevice(), deviceInfo, BluetoothLinkProvider.this);
DeviceInfo myDeviceInfo = DeviceHelper.getDeviceInfo(context);
NetworkPacket np2 = myDeviceInfo.toIdentityPacket();
np2.set("certificate", Base64.encodeToString(SslHelper.certificate.getEncoded(), 0));
NetworkPacket np2 = NetworkPacket.createIdentityPacket(context);
link.sendPacket(np2, new Device.SendPacketStatusCallback() {
@Override
public void onSuccess() {

13
src/org/kde/kdeconnect/Backends/LanBackend/LanLink.java
View File

@ -16,6 +16,7 @@ import org.json.JSONObject;
import org.kde.kdeconnect.Backends.BaseLink;
import org.kde.kdeconnect.Backends.BaseLinkProvider;
import org.kde.kdeconnect.Device;
import org.kde.kdeconnect.DeviceInfo;
import org.kde.kdeconnect.Helpers.SecurityHelpers.SslHelper;
import org.kde.kdeconnect.Helpers.ThreadHelper;
import org.kde.kdeconnect.NetworkPacket;
@ -42,6 +43,8 @@ public class LanLink extends BaseLink {
Locally, Remotely
}
private final DeviceInfo deviceInfo;
private volatile SSLSocket socket = null;
@Override
@ -99,8 +102,9 @@ public class LanLink extends BaseLink {
return oldSocket;
}
public LanLink(Context context, String deviceId, BaseLinkProvider linkProvider, SSLSocket socket) throws IOException {
super(context, deviceId, linkProvider);
public LanLink(@NonNull Context context, @NonNull DeviceInfo deviceInfo, @NonNull BaseLinkProvider linkProvider, @NonNull SSLSocket socket) throws IOException {
super(context, linkProvider);
this.deviceInfo = deviceInfo;
reset(socket);
}
@ -109,6 +113,11 @@ public class LanLink extends BaseLink {
return "LanLink";
}
@Override
public DeviceInfo getDeviceInfo() {
return deviceInfo;
}
@WorkerThread
@Override
public boolean sendPacket(@NonNull NetworkPacket np, @NonNull final Device.SendPacketStatusCallback callback, boolean sendPayloadFromSameThread) {

56
src/org/kde/kdeconnect/Backends/LanBackend/LanLinkProvider.java
View File

@ -17,6 +17,7 @@ import org.json.JSONException;
import org.kde.kdeconnect.Backends.BaseLink;
import org.kde.kdeconnect.Backends.BaseLinkProvider;
import org.kde.kdeconnect.Device;
import org.kde.kdeconnect.DeviceInfo;
import org.kde.kdeconnect.Helpers.DeviceHelper;
import org.kde.kdeconnect.Helpers.SecurityHelpers.SslHelper;
import org.kde.kdeconnect.Helpers.ThreadHelper;
@ -50,7 +51,7 @@ import kotlin.text.Charsets;
/**
* This LanLinkProvider creates {@link LanLink}s to other devices on the same
* WiFi network. The first packet sent over a socket must be an
* {@link NetworkPacket#createIdentityPacket(Context)}.
* {@link DeviceInfo#toIdentityPacket()}.
*
* @see #identityPacketReceived(NetworkPacket, Socket, LanLink.ConnectionStarted)
*/
@ -128,13 +129,19 @@ public class LanLinkProvider extends BaseLinkProvider {
Log.i("KDE/LanLinkProvider", "Broadcast identity packet received from " + identityPacket.getString("deviceName"));
int tcpPort = identityPacket.getInt("tcpPort", MIN_PORT);
if (tcpPort < MIN_PORT || tcpPort > MAX_PORT) {
Log.e("LanLinkProvider", "TCP port outside of kdeconnect's range");
return;
}
SocketFactory socketFactory = SocketFactory.getDefault();
Socket socket = socketFactory.createSocket(address, tcpPort);
configureSocket(socket);
DeviceInfo myDeviceInfo = DeviceHelper.getDeviceInfo(context);
NetworkPacket myIdentity = myDeviceInfo.toIdentityPacket();
OutputStream out = socket.getOutputStream();
NetworkPacket myIdentity = NetworkPacket.createIdentityPacket(context);
out.write(myIdentity.serialize().getBytes());
out.flush();
@ -190,17 +197,19 @@ public class LanLinkProvider extends BaseLinkProvider {
identityPacketReceived(identityPacket, socket, connectionStarted);
}
Log.i("KDE/LanLinkProvider", "Starting SSL handshake with " + identityPacket.getString("deviceName") + " trusted:" + isDeviceTrusted);
String deviceName = identityPacket.getString("deviceName", "unknown");
Log.i("KDE/LanLinkProvider", "Starting SSL handshake with " + deviceName + " trusted:" + isDeviceTrusted);
final SSLSocket sslSocket = SslHelper.convertToSslSocket(context, socket, deviceId, isDeviceTrusted, clientMode);
sslSocket.addHandshakeCompletedListener(event -> {
String mode = clientMode ? "client" : "server";
try {
Certificate certificate = event.getPeerCertificates()[0];
Log.i("KDE/LanLinkProvider", "Handshake as " + mode + " successful with " + identityPacket.getString("deviceName") + " secured with " + event.getCipherSuite());
addLink(deviceId, certificate, identityPacket, sslSocket);
} catch (Exception e) {
Log.e("KDE/LanLinkProvider", "Handshake as " + mode + " failed with " + identityPacket.getString("deviceName"), e);
DeviceInfo deviceInfo = DeviceInfo.fromIdentityPacketAndCert(identityPacket, certificate);
Log.i("KDE/LanLinkProvider", "Handshake as " + mode + " successful with " + deviceName + " secured with " + event.getCipherSuite());
addLink(sslSocket, deviceInfo);
} catch (IOException e) {
Log.e("KDE/LanLinkProvider", "Handshake as " + mode + " failed with " + deviceName, e);
Device device = KdeConnect.getInstance().getDevice(deviceId);
if (device == null) {
return;
@ -218,24 +227,26 @@ public class LanLinkProvider extends BaseLinkProvider {
/**
* Add or update a link in the {@link #visibleDevices} map.
*
* @param deviceId remote device id
* @param certificate remote device certificate
* @param identityPacket identity packet with the remote device's device name, type, protocol version, etc.
* @param socket a new Socket, which should be used to send and receive packets from the remote device
* @param deviceInfo remote device info
* @throws IOException if an exception is thrown by {@link LanLink#reset(SSLSocket)}
*/
private void addLink(String deviceId, Certificate certificate, final NetworkPacket identityPacket, SSLSocket socket) throws IOException {
LanLink currentLink = visibleDevices.get(deviceId);
if (currentLink != null) {
//Update old link
Log.i("KDE/LanLinkProvider", "Reusing same link for device " + deviceId);
final Socket oldSocket = currentLink.reset(socket);
private void addLink(SSLSocket socket, DeviceInfo deviceInfo) throws IOException {
LanLink link = visibleDevices.get(deviceInfo.id);
if (link != null) {
if (!link.getDeviceInfo().certificate.equals(deviceInfo.certificate)) {
Log.e("LanLinkProvider", "LanLink was asked to replace a socket but the certificate doesn't match, aborting");
return;
}
// Update existing link
Log.d("KDE/LanLinkProvider", "Reusing same link for device " + deviceInfo.id);
final Socket oldSocket = link.reset(socket);
} else {
Log.i("KDE/LanLinkProvider", "Creating a new link for device " + deviceId);
//Let's create the link
LanLink link = new LanLink(context, deviceId, this, socket);
visibleDevices.put(deviceId, link);
onConnectionReceived(deviceId, certificate, identityPacket, link);
// Create a new link
Log.d("KDE/LanLinkProvider", "Creating a new link for device " + deviceInfo.id);
link = new LanLink(context, deviceInfo, this, socket);
visibleDevices.put(deviceInfo.id, link);
onConnectionReceived(link);
}
}
@ -368,7 +379,8 @@ public class LanLinkProvider extends BaseLinkProvider {
return;
}
NetworkPacket identity = NetworkPacket.createIdentityPacket(context);
DeviceInfo myDeviceInfo = DeviceHelper.getDeviceInfo(context);
NetworkPacket identity = myDeviceInfo.toIdentityPacket();
identity.set("tcpPort", tcpServer.getLocalPort());
byte[] bytes;

9
src/org/kde/kdeconnect/Backends/LoopbackBackend/LoopbackLink.java
View File

@ -14,12 +14,14 @@ import androidx.annotation.WorkerThread;
import org.kde.kdeconnect.Backends.BaseLink;
import org.kde.kdeconnect.Backends.BaseLinkProvider;
import org.kde.kdeconnect.Device;
import org.kde.kdeconnect.DeviceInfo;
import org.kde.kdeconnect.Helpers.DeviceHelper;
import org.kde.kdeconnect.NetworkPacket;
public class LoopbackLink extends BaseLink {
public LoopbackLink(Context context, BaseLinkProvider linkProvider) {
super(context, "loopback", linkProvider);
super(context, linkProvider);
}
@Override
@ -40,4 +42,9 @@ public class LoopbackLink extends BaseLink {
return true;
}
@Override
public DeviceInfo getDeviceInfo() {
return DeviceHelper.getDeviceInfo(context);
}
}

8
src/org/kde/kdeconnect/Backends/LoopbackBackend/LoopbackLinkProvider.java
View File

@ -9,9 +9,6 @@ package org.kde.kdeconnect.Backends.LoopbackBackend;
import android.content.Context;
import org.kde.kdeconnect.Backends.BaseLinkProvider;
import org.kde.kdeconnect.Helpers.DeviceHelper;
import org.kde.kdeconnect.Helpers.SecurityHelpers.SslHelper;
import org.kde.kdeconnect.NetworkPacket;
public class LoopbackLinkProvider extends BaseLinkProvider {
@ -32,9 +29,8 @@ public class LoopbackLinkProvider extends BaseLinkProvider {
@Override
public void onNetworkChange() {
NetworkPacket np = NetworkPacket.createIdentityPacket(context);
String deviceId = DeviceHelper.getDeviceId(context);
onConnectionReceived(deviceId, SslHelper.certificate, np, new LoopbackLink(context, this));
LoopbackLink link = new LoopbackLink(context, this);
onConnectionReceived(link);
}
@Override

210
src/org/kde/kdeconnect/Device.java
View File

@ -14,7 +14,6 @@ import android.content.Intent;
import android.content.SharedPreferences;
import android.content.res.Resources;
import android.graphics.drawable.Drawable;
import android.util.Base64;
import android.util.Log;
import androidx.annotation.AnyThread;
@ -26,7 +25,6 @@ import androidx.core.content.ContextCompat;
import org.apache.commons.collections4.MultiValuedMap;
import org.apache.commons.collections4.multimap.ArrayListValuedHashMap;
import org.apache.commons.lang3.StringUtils;
import org.kde.kdeconnect.Backends.BaseLink;
import org.kde.kdeconnect.Helpers.DeviceHelper;
import org.kde.kdeconnect.Helpers.NotificationHelper;
@ -38,13 +36,8 @@ import org.kde.kdeconnect_tp.R;
import java.io.IOException;
import java.security.cert.Certificate;
import java.security.cert.CertificateEncodingException;
import java.security.cert.CertificateException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.Vector;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
@ -53,30 +46,26 @@ public class Device implements BaseLink.PacketReceiver {
private final Context context;
private final String deviceId;
private String name;
public Certificate certificate;
final DeviceInfo deviceInfo;
private int notificationId;
private int protocolVersion;
private DeviceType deviceType;
PairingHandler pairingHandler;
private final CopyOnWriteArrayList<PairingHandler.PairingCallback> pairingCallbacks = new CopyOnWriteArrayList<>();
private final CopyOnWriteArrayList<BaseLink> links = new CopyOnWriteArrayList<>();
private DevicePacketQueue packetQueue;
private List<String> supportedPlugins = new ArrayList<>();
private List<String> supportedPlugins;
private final ConcurrentHashMap<String, Plugin> plugins = new ConcurrentHashMap<>();
private final ConcurrentHashMap<String, Plugin> pluginsWithoutPermissions = new ConcurrentHashMap<>();
private final ConcurrentHashMap<String, Plugin> pluginsWithoutOptionalPermissions = new ConcurrentHashMap<>();
private MultiValuedMap<String, String> pluginsByIncomingInterface = new ArrayListValuedHashMap<>();
private final SharedPreferences settings;
private final CopyOnWriteArrayList<PluginsChangedListener> pluginsChangedListeners = new CopyOnWriteArrayList<>();
private Set<String> incomingCapabilities = new HashSet<>();
public boolean supportsPacketType(String type) {
if (incomingCapabilities == null) {
if (deviceInfo.incomingCapabilities == null) {
return true;
} else {
return incomingCapabilities.contains(type);
return deviceInfo.incomingCapabilities.contains(type);
}
}
@ -84,109 +73,52 @@ public class Device implements BaseLink.PacketReceiver {
void onPluginsChanged(@NonNull Device device);
}
public enum DeviceType {
Phone,
Tablet,
Computer,
Tv;
static public DeviceType FromString(String s) {
if ("tablet".equals(s)) return Tablet;
if ("phone".equals(s)) return Phone;
if ("tv".equals(s)) return Tv;
return Computer; //Default
}
@NonNull
public String toString() {
switch (this) {
case Tablet:
return "tablet";
case Phone:
return "phone";
case Tv:
return "tv";
default:
return "desktop";
}
}
public Drawable getIcon(Context context) {
int drawableId;
switch (this) {
case Phone:
drawableId = R.drawable.ic_device_phone_32dp;
break;
case Tablet:
drawableId = R.drawable.ic_device_tablet_32dp;
break;
case Tv:
drawableId = R.drawable.ic_device_tv_32dp;
break;
default:
drawableId = R.drawable.ic_device_laptop_32dp;
}
return ContextCompat.getDrawable(context, drawableId);
}
}
// Remembered trusted device, we need to wait for a incoming Link to communicate
Device(@NonNull Context context, @NonNull String deviceId) throws CertificateException {
/**
* Constructor for remembered, already-trusted devices.
* Given the deviceId, it will load the other properties from SharedPreferences.
*/
Device(@NonNull Context context, @NonNull String deviceId) {
this.context = context;
this.settings = context.getSharedPreferences(deviceId, Context.MODE_PRIVATE);
this.deviceInfo = DeviceInfo.loadFromSettings(context, deviceId, settings);
this.pairingHandler = new PairingHandler(this, pairingCallback, PairingHandler.PairState.Paired);
this.deviceId = deviceId;
this.name = settings.getString("deviceName", context.getString(R.string.unknown_device));
this.protocolVersion = 0; //We don't know it yet
this.deviceType = DeviceType.FromString(settings.getString("deviceType", "desktop"));
this.certificate = SslHelper.getDeviceCertificate(context, deviceId);
Log.i("Device","Loading trusted device: " + this.name);
//Assume every plugin is supported until addLink is called and we can get the actual list
supportedPlugins = new Vector<>(PluginFactory.getAvailablePlugins());
//Do not load plugins yet, the device is not present
//reloadPluginsFromSettings();
this.supportedPlugins = new Vector<>(PluginFactory.getAvailablePlugins()); // Assume all are supported until we receive capabilities
Log.i("Device","Loading trusted device: " + deviceInfo.name);
}
// Device known via an incoming connection sent to us via a Link, we don't trust it yet
Device(@NonNull Context context, @NonNull String deviceId, @NonNull Certificate certificate, @NonNull NetworkPacket identityPacket, @NonNull BaseLink dl) {
Log.i("Device","Creating untrusted device");
/**
* Constructor for devices discovered but not trusted yet.
* Gets the DeviceInfo by calling link.getDeviceInfo() on the link passed.
* This constructor also calls addLink() with the link you pass to it, since it's not legal to have an unpaired Device with 0 links.
*/
Device(@NonNull Context context, @NonNull BaseLink link) {
this.context = context;
this.settings = context.getSharedPreferences(deviceId, Context.MODE_PRIVATE);
this.deviceInfo = link.getDeviceInfo();
this.settings = context.getSharedPreferences(deviceInfo.id, Context.MODE_PRIVATE);
this.pairingHandler = new PairingHandler(this, pairingCallback, PairingHandler.PairState.NotPaired);
this.deviceId = deviceId;
this.certificate = certificate;
// The following properties are read from the identityPacket in addLink since they can change in future identity packets
this.name = context.getString(R.string.unknown_device);
this.deviceType = DeviceType.Computer;
this.protocolVersion = 0;
addLink(identityPacket, dl);
this.supportedPlugins = new Vector<>(PluginFactory.getAvailablePlugins()); // Assume all are supported until we receive capabilities
Log.i("Device","Creating untrusted device: "+ deviceInfo.name);
addLink(link);
}
public String getName() {
return StringUtils.defaultString(name, context.getString(R.string.unknown_device));
return deviceInfo.name;
}
public Drawable getIcon() {
return deviceType.getIcon(context);
return deviceInfo.type.getIcon(context);
}
public DeviceType getDeviceType() {
return deviceType;
return deviceInfo.type;
}
public String getDeviceId() {
return deviceId;
return deviceInfo.id;
}
public Certificate getCertificate() {
return deviceInfo.certificate;
}
public Context getContext() {
@ -195,7 +127,7 @@ public class Device implements BaseLink.PacketReceiver {
//Returns 0 if the version matches, < 0 if it is older or > 0 if it is newer
public int compareProtocolVersion() {
return protocolVersion - DeviceHelper.ProtocolVersion;
return deviceInfo.protocolVersion - DeviceHelper.ProtocolVersion;
}
@ -257,20 +189,11 @@ public class Device implements BaseLink.PacketReceiver {
hidePairingNotification();
// Store current device certificate so we can check it in the future (TOFU)
SharedPreferences.Editor editor = context.getSharedPreferences(getDeviceId(), Context.MODE_PRIVATE).edit();
try {
String encodedCertificate = Base64.encodeToString(certificate.getEncoded(), 0);
editor.putString("certificate", encodedCertificate);
} catch(CertificateEncodingException e) {
throw new RuntimeException(e);
}
editor.putString("deviceName", name);
editor.putString("deviceType", deviceType.toString());
editor.apply();
deviceInfo.saveInSettings(Device.this.settings);
// Store as trusted device
SharedPreferences preferences = context.getSharedPreferences("trusted_devices", Context.MODE_PRIVATE);
preferences.edit().putBoolean(deviceId, true).apply();
preferences.edit().putBoolean(deviceInfo.id, true).apply();
reloadPluginsFromSettings();
@ -290,9 +213,9 @@ public class Device implements BaseLink.PacketReceiver {
@Override
public void unpaired() {
SharedPreferences preferences = context.getSharedPreferences("trusted_devices", Context.MODE_PRIVATE);
preferences.edit().remove(deviceId).apply();
preferences.edit().remove(deviceInfo.id).apply();
SharedPreferences devicePreferences = context.getSharedPreferences(deviceId, Context.MODE_PRIVATE);
SharedPreferences devicePreferences = context.getSharedPreferences(deviceInfo.id, Context.MODE_PRIVATE);
devicePreferences.edit().clear().apply();
for (PairingHandler.PairingCallback cb : pairingCallbacks) {
@ -334,7 +257,7 @@ public class Device implements BaseLink.PacketReceiver {
final NotificationManager notificationManager = ContextCompat.getSystemService(getContext(), NotificationManager.class);
String verificationKeyShort = SslHelper.getVerificationKey(SslHelper.certificate, certificate).substring(8);
String verificationKeyShort = SslHelper.getVerificationKey(SslHelper.certificate, deviceInfo.certificate).substring(8);
Notification noti = new NotificationCompat.Builder(getContext(), NotificationHelper.Channels.DEFAULT)
.setContentTitle(res.getString(R.string.pairing_request_from, getName()))
@ -365,7 +288,7 @@ public class Device implements BaseLink.PacketReceiver {
return !links.isEmpty();
}
public void addLink(NetworkPacket identityPacket, BaseLink link) {
public void addLink(BaseLink link) {
if (links.isEmpty()) {
packetQueue = new DevicePacketQueue(this);
}
@ -373,33 +296,11 @@ public class Device implements BaseLink.PacketReceiver {
links.add(link);
link.addPacketReceiver(this);
this.protocolVersion = identityPacket.getInt("protocolVersion");
if (identityPacket.has("deviceName")) {
this.name = identityPacket.getString("deviceName", this.name);
SharedPreferences.Editor editor = settings.edit();
editor.putString("deviceName", this.name);
editor.apply();
}
if (identityPacket.has("deviceType")) {
this.deviceType = DeviceType.FromString(identityPacket.getString("deviceType", "desktop"));
}
Log.i("KDE/Device", "addLink " + link.getLinkProvider().getName() + " -> " + getName() + " active links: " + links.size());
Set<String> outgoingCapabilities = identityPacket.getStringSet("outgoingCapabilities", null);
Set<String> incomingCapabilities = identityPacket.getStringSet("incomingCapabilities", null);
if (incomingCapabilities != null && outgoingCapabilities != null) {
supportedPlugins = new Vector<>(PluginFactory.pluginsForCapabilities(incomingCapabilities, outgoingCapabilities));
} else {
supportedPlugins = new Vector<>(PluginFactory.getAvailablePlugins());
}
this.incomingCapabilities = incomingCapabilities;
boolean hasChanges = updateDeviceInfo(link.getDeviceInfo());
if (hasChanges || links.size() == 1) {
reloadPluginsFromSettings();
}
}
public void removeLink(BaseLink link) {
@ -417,6 +318,30 @@ public class Device implements BaseLink.PacketReceiver {
}
}
public boolean updateDeviceInfo(@NonNull DeviceInfo newDeviceInfo) {
boolean hasChanges = false;
if (!deviceInfo.name.equals(newDeviceInfo.name) || deviceInfo.type != newDeviceInfo.type) {
hasChanges = true;
deviceInfo.name = newDeviceInfo.name;
deviceInfo.type = newDeviceInfo.type;
if (isPaired()) {
deviceInfo.saveInSettings(settings);
}
}
if (deviceInfo.outgoingCapabilities != newDeviceInfo.outgoingCapabilities ||
deviceInfo.incomingCapabilities != newDeviceInfo.incomingCapabilities) {
if (newDeviceInfo.outgoingCapabilities != null && newDeviceInfo.incomingCapabilities != null) {
hasChanges = true;
Log.i("updateDeviceInfo", "Updating supported plugins according to new capabilities");
supportedPlugins = new Vector<>(PluginFactory.pluginsForCapabilities(newDeviceInfo.incomingCapabilities, newDeviceInfo.outgoingCapabilities));
}
}
return hasChanges;
}
@Override
public void onPacketReceived(@NonNull NetworkPacket np) {
@ -580,7 +505,7 @@ public class Device implements BaseLink.PacketReceiver {
}
if (!success) {
Log.e("KDE/sendPacket", "No device link (of " + links.size() + " available) could send the packet. Packet " + np.getType() + " to " + name + " lost!");
Log.e("KDE/sendPacket", "No device link (of " + links.size() + " available) could send the packet. Packet " + np.getType() + " to " + deviceInfo.name + " lost!");
}
return success;
@ -697,6 +622,7 @@ public class Device implements BaseLink.PacketReceiver {
}
public void reloadPluginsFromSettings() {
Log.i("Device", deviceInfo.name +": reloading plugins");
MultiValuedMap<String, String> newPluginsByIncomingInterface = new ArrayListValuedHashMap<>();
for (String pluginKey : supportedPlugins) {

133
src/org/kde/kdeconnect/DeviceInfo.kt Normal file
View File

@ -0,0 +1,133 @@
/*
* SPDX-FileCopyrightText: 2023 Albert Vaca Cintora <albertvaka@gmail.com>
*
* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
*/
package org.kde.kdeconnect
import android.content.Context
import android.content.SharedPreferences
import android.graphics.drawable.Drawable
import android.util.Base64
import androidx.core.content.ContextCompat
import org.kde.kdeconnect.Helpers.SecurityHelpers.SslHelper
import org.kde.kdeconnect_tp.R
import java.security.cert.Certificate
import java.security.cert.CertificateEncodingException
/**
* DeviceInfo contains all the properties needed to instantiate a Device.
*/
class DeviceInfo(
@JvmField val id : String,
@JvmField val certificate : Certificate,
@JvmField var name : String,
@JvmField var type : DeviceType,
@JvmField var protocolVersion : Int = 0,
@JvmField var incomingCapabilities : Set<String>? = null,
@JvmField var outgoingCapabilities : Set<String>? = null,
) {
/**
* Saves the info in settings so it can be restored later using loadFromSettings().
* This is used to keep info from paired devices, even when they are not reachable.
* The capabilities and protocol version are not persisted.
*/
fun saveInSettings(settings: SharedPreferences) {
val editor = settings.edit()
try {
val encodedCertificate = Base64.encodeToString(certificate.encoded, 0)
editor.putString("certificate", encodedCertificate)
} catch (e: CertificateEncodingException) {
throw RuntimeException(e)
}
editor.putString("deviceName", name)
editor.putString("deviceType", type.toString())
editor.apply()
}
/**
* Serializes to a NetworkPacket, which LanLinkProvider uses to send this data over the network.
* The serialization doesn't include the certificate, since LanLink can query that from the socket.
* Can be deserialized using fromIdentityPacketAndCert(), given a certificate.
*/
fun toIdentityPacket(): NetworkPacket {
val np = NetworkPacket(NetworkPacket.PACKET_TYPE_IDENTITY)
np.set("deviceId", id)
np.set("deviceName", name)
np.set("protocolVersion", protocolVersion)
np.set("deviceType", type.toString())
np.set("incomingCapabilities", incomingCapabilities)
np.set("outgoingCapabilities", outgoingCapabilities)
return np
}
companion object {
/**
* Recreates a DeviceInfo object that was persisted using saveInSettings()
*/
@JvmStatic
fun loadFromSettings(context : Context, deviceId: String, settings: SharedPreferences): DeviceInfo {
val deviceName = settings.getString("deviceName", "unknown")!!
val deviceType = DeviceType.fromString(settings.getString("deviceType", "desktop")!!)
val certificate = SslHelper.getDeviceCertificate(context, deviceId)
return DeviceInfo(id = deviceId, name = deviceName, type = deviceType, certificate = certificate)
}
/**
* Recreates a DeviceInfo object that was serialized using toIdentityPacket().
* Since toIdentityPacket() doesn't serialize the certificate, this needs to be passed separately.
*/
@JvmStatic
fun fromIdentityPacketAndCert(identityPacket : NetworkPacket, certificate : Certificate): DeviceInfo {
val deviceId = identityPacket.getString("deviceId")
val deviceName = identityPacket.getString("deviceName", "unknown")
val protocolVersion = identityPacket.getInt("protocolVersion")
val deviceType = DeviceType.fromString(identityPacket.getString("deviceType", "desktop"))
val incomingCapabilities = identityPacket.getStringSet("incomingCapabilities")
val outgoingCapabilities = identityPacket.getStringSet("outgoingCapabilities")
return DeviceInfo(id = deviceId, name = deviceName, type = deviceType, certificate = certificate,
protocolVersion = protocolVersion, incomingCapabilities = incomingCapabilities, outgoingCapabilities = outgoingCapabilities)
}
}
}
enum class DeviceType {
Phone, Tablet, Computer, Tv;
override fun toString(): String {
return when (this) {
Tablet -> "tablet"
Phone -> "phone"
Tv -> "tv"
else -> "desktop"
}
}
fun getIcon(context: Context): Drawable? {
val drawableId: Int = when (this) {
Phone -> R.drawable.ic_device_phone_32dp
Tablet -> R.drawable.ic_device_tablet_32dp
Tv -> R.drawable.ic_device_tv_32dp
else -> R.drawable.ic_device_laptop_32dp
}
return ContextCompat.getDrawable(context, drawableId)
}
companion object {
@JvmStatic
fun fromString(s: String): DeviceType {
return when (s) {
"phone" -> Phone
"tablet" -> Tablet
"tv" -> Tv
else -> Computer
}
}
}
}

23
src/org/kde/kdeconnect/Helpers/DeviceHelper.java
View File

@ -19,7 +19,10 @@ import android.util.Log;
import com.univocity.parsers.csv.CsvParser;
import com.univocity.parsers.csv.CsvParserSettings;
import org.kde.kdeconnect.Device;
import org.kde.kdeconnect.DeviceInfo;
import org.kde.kdeconnect.DeviceType;
import org.kde.kdeconnect.Helpers.SecurityHelpers.SslHelper;
import org.kde.kdeconnect.Plugins.PluginFactory;
import java.io.BufferedReader;
import java.io.IOException;
@ -53,13 +56,13 @@ public class DeviceHelper {
return (uiMode & Configuration.UI_MODE_TYPE_MASK) == Configuration.UI_MODE_TYPE_TELEVISION;
}
public static Device.DeviceType getDeviceType(Context context) {
public static DeviceType getDeviceType(Context context) {
if (isTv(context)) {
return Device.DeviceType.Tv;
return DeviceType.Tv;
} else if (isTablet()) {
return Device.DeviceType.Tablet;
return DeviceType.Tablet;
} else {
return Device.DeviceType.Phone;
return DeviceType.Phone;
}
}
@ -146,4 +149,14 @@ public class DeviceHelper {
return preferences.getString(KEY_DEVICE_ID_PREFERENCE, null);
}
public static DeviceInfo getDeviceInfo(Context context) {
return new DeviceInfo(getDeviceId(context),
SslHelper.certificate,
getDeviceName(context),
DeviceHelper.getDeviceType(context),
ProtocolVersion,
PluginFactory.getIncomingCapabilities(),
PluginFactory.getOutgoingCapabilities());
}
}

22
src/org/kde/kdeconnect/KdeConnect.java
View File

@ -24,8 +24,6 @@ import org.kde.kdeconnect.Plugins.Plugin;
import org.kde.kdeconnect.Plugins.PluginFactory;
import org.kde.kdeconnect.UserInterface.ThemeUtil;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
@ -115,14 +113,9 @@ public class KdeConnect extends Application {
for (String deviceId : trustedDevices) {
//Log.e("BackgroundService", "Loading device "+deviceId);
if (preferences.getBoolean(deviceId, false)) {
try {
Device device = new Device(this, deviceId);
devices.put(deviceId, device);
device.addPairingCallback(devicePairingCallback);
} catch (CertificateException e) {
Log.e("KdeConnect", "Could not load trusted device, certificate not valid: " + deviceId);
e.printStackTrace();
}
}
}
}
@ -151,18 +144,13 @@ public class KdeConnect extends Application {
private final BaseLinkProvider.ConnectionReceiver connectionListener = new BaseLinkProvider.ConnectionReceiver() {
@Override
public void onConnectionReceived(@NonNull final String deviceId,
@NonNull final Certificate certificate,
@NonNull final NetworkPacket identityPacket,
@NonNull final BaseLink link) {
Device device = devices.get(deviceId);
public void onConnectionReceived(@NonNull final BaseLink link) {
Device device = devices.get(link.getDeviceId());
if (device != null) {
Log.i("KDE/Application", "addLink, known device: " + deviceId);
device.addLink(identityPacket, link);
device.addLink(link);
} else {
Log.i("KDE/Application", "addLink,unknown device: " + deviceId);
device = new Device(KdeConnect.this, deviceId, certificate, identityPacket, link);
devices.put(deviceId, device);
device = new Device(KdeConnect.this, link);
devices.put(link.getDeviceId(), device);
device.addPairingCallback(devicePairingCallback);
}
onDeviceListChanged();

25
src/org/kde/kdeconnect/NetworkPacket.java
View File

@ -6,15 +6,10 @@
package org.kde.kdeconnect;
import android.content.Context;
import android.util.Log;
import org.apache.commons.io.IOUtils;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.kde.kdeconnect.Helpers.DeviceHelper;
import org.kde.kdeconnect.Plugins.PluginFactory;
import java.io.ByteArrayInputStream;
import java.io.IOException;
@ -263,26 +258,6 @@ public class NetworkPacket {
return np;
}
static public NetworkPacket createIdentityPacket(Context context) {
NetworkPacket np = new NetworkPacket(NetworkPacket.PACKET_TYPE_IDENTITY);
String deviceId = DeviceHelper.getDeviceId(context);
try {
np.mBody.put("deviceId", deviceId);
np.mBody.put("deviceName", DeviceHelper.getDeviceName(context));
np.mBody.put("protocolVersion", DeviceHelper.ProtocolVersion);
np.mBody.put("deviceType", DeviceHelper.getDeviceType(context).toString());
np.mBody.put("incomingCapabilities", new JSONArray(PluginFactory.getIncomingCapabilities()));
np.mBody.put("outgoingCapabilities", new JSONArray(PluginFactory.getOutgoingCapabilities()));
} catch (Exception e) {
Log.e("NetworkPacket", "Exception on createIdentityPacket", e);
}
return np;
}
public void setPayload(Payload payload) { mPayload = payload; }
public Payload getPayload() {

4
src/org/kde/kdeconnect/Plugins/BigscreenPlugin/BigscreenPlugin.java
View File

@ -19,7 +19,7 @@ import android.view.KeyEvent;
import androidx.annotation.DrawableRes;
import androidx.annotation.NonNull;
import org.kde.kdeconnect.Device;
import org.kde.kdeconnect.DeviceType;
import org.kde.kdeconnect.NetworkPacket;
import org.kde.kdeconnect.Plugins.Plugin;
import org.kde.kdeconnect.Plugins.PluginFactory;
@ -33,7 +33,7 @@ public class BigscreenPlugin extends Plugin {
@Override
public boolean isCompatible() {
return device.getDeviceType().equals(Device.DeviceType.Tv) && super.isCompatible();
return device.getDeviceType().equals(DeviceType.Tv) && super.isCompatible();
}
@Override

4
src/org/kde/kdeconnect/Plugins/PresenterPlugin/PresenterPlugin.java
View File

@ -18,7 +18,7 @@ import androidx.annotation.DrawableRes;
import androidx.annotation.NonNull;
import org.apache.commons.lang3.ArrayUtils;
import org.kde.kdeconnect.Device;
import org.kde.kdeconnect.DeviceType;
import org.kde.kdeconnect.NetworkPacket;
import org.kde.kdeconnect.Plugins.Plugin;
import org.kde.kdeconnect.Plugins.PluginFactory;
@ -41,7 +41,7 @@ public class PresenterPlugin extends Plugin {
@Override
public boolean isCompatible() {
return !device.getDeviceType().equals(Device.DeviceType.Phone) && super.isCompatible();
return !device.getDeviceType().equals(DeviceType.Phone) && super.isCompatible();
}
@Override

2
src/org/kde/kdeconnect/Plugins/SftpPlugin/SimpleSftpServer.java
View File

@ -92,7 +92,7 @@ class SimpleSftpServer {
sshd.setCommandFactory(new ScpCommandFactory());
sshd.setSubsystemFactories(Collections.singletonList(new SftpSubsystem.Factory()));
keyAuth.deviceKey = device.certificate.getPublicKey();
keyAuth.deviceKey = device.getCertificate().getPublicKey();
sshd.setPublickeyAuthenticator(keyAuth);
sshd.setPasswordAuthenticator(passwordAuth);

28
tests/org/kde/kdeconnect/DeviceTest.java
View File

@ -84,7 +84,7 @@ public class DeviceTest {
MockSharedPreference deviceSettings = new MockSharedPreference();
SharedPreferences.Editor editor = deviceSettings.edit();
editor.putString("deviceName", name);
editor.putString("deviceType", Device.DeviceType.Phone.toString());
editor.putString("deviceType", DeviceType.Phone.toString());
editor.putString("certificate", encodedCertificate);
editor.apply();
Mockito.when(context.getSharedPreferences(eq(deviceId), eq(Context.MODE_PRIVATE))).thenReturn(deviceSettings);
@ -110,12 +110,11 @@ public class DeviceTest {
@Test
public void testDeviceType() {
assertEquals(Device.DeviceType.Phone, Device.DeviceType.FromString(Device.DeviceType.Phone.toString()));
assertEquals(Device.DeviceType.Tablet, Device.DeviceType.FromString(Device.DeviceType.Tablet.toString()));
assertEquals(Device.DeviceType.Computer, Device.DeviceType.FromString(Device.DeviceType.Computer.toString()));
assertEquals(Device.DeviceType.Tv, Device.DeviceType.FromString(Device.DeviceType.Tv.toString()));
assertEquals(Device.DeviceType.Computer, Device.DeviceType.FromString(""));
assertEquals(Device.DeviceType.Computer, Device.DeviceType.FromString(null));
assertEquals(DeviceType.Phone, DeviceType.fromString(DeviceType.Phone.toString()));
assertEquals(DeviceType.Tablet, DeviceType.fromString(DeviceType.Tablet.toString()));
assertEquals(DeviceType.Computer, DeviceType.fromString(DeviceType.Computer.toString()));
assertEquals(DeviceType.Tv, DeviceType.fromString(DeviceType.Tv.toString()));
assertEquals(DeviceType.Computer, DeviceType.fromString("invalid"));
}
// Basic paired device testing
@ -124,10 +123,10 @@ public class DeviceTest {
Device device = new Device(context, "testDevice");
assertEquals(device.getDeviceId(), "testDevice");
assertEquals(device.getDeviceType(), Device.DeviceType.Phone);
assertEquals(device.getDeviceType(), DeviceType.Phone);
assertEquals(device.getName(), "Test Device");
assertTrue(device.isPaired());
assertNotNull(device.certificate);
assertNotNull(device.deviceInfo.certificate);
}
public void testPairingDone() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException, CertificateException {
@ -137,7 +136,7 @@ public class DeviceTest {
fakeNetworkPacket.set("deviceId", deviceId);
fakeNetworkPacket.set("deviceName", "Unpaired Test Device");
fakeNetworkPacket.set("protocolVersion", DeviceHelper.ProtocolVersion);
fakeNetworkPacket.set("deviceType", Device.DeviceType.Phone.toString());
fakeNetworkPacket.set("deviceType", DeviceType.Phone.toString());
String certificateString =
"MIIDVzCCAj+gAwIBAgIBCjANBgkqhkiG9w0BAQUFADBVMS8wLQYDVQQDDCZfZGExNzlhOTFfZjA2\n" +
"NF80NzhlX2JlOGNfMTkzNWQ3NTQ0ZDU0XzEMMAoGA1UECgwDS0RFMRQwEgYDVQQLDAtLZGUgY29u\n" +
@ -157,18 +156,21 @@ public class DeviceTest {
"7n+KOQ==";
byte[] certificateBytes = Base64.decode(certificateString, 0);
Certificate certificate = SslHelper.parseCertificate(certificateBytes);
DeviceInfo deviceInfo = DeviceInfo.fromIdentityPacketAndCert(fakeNetworkPacket, certificate);
LanLinkProvider linkProvider = Mockito.mock(LanLinkProvider.class);
Mockito.when(linkProvider.getName()).thenReturn("LanLinkProvider");
LanLink link = Mockito.mock(LanLink.class);
Mockito.when(link.getLinkProvider()).thenReturn(linkProvider);
Device device = new Device(context, deviceId, certificate, fakeNetworkPacket, link);
Mockito.when(link.getDeviceId()).thenReturn(deviceId);
Mockito.when(link.getDeviceInfo()).thenReturn(deviceInfo);
Device device = new Device(context, link);
assertNotNull(device);
assertEquals(device.getDeviceId(), deviceId);
assertEquals(device.getName(), "Unpaired Test Device");
assertEquals(device.getDeviceType(), Device.DeviceType.Phone);
assertNotNull(device.certificate);
assertEquals(device.getDeviceType(), DeviceType.Phone);
assertNotNull(device.deviceInfo.certificate);
Method method = PairingHandler.class.getDeclaredMethod("pairingDone");
method.setAccessible(true);

27
tests/org/kde/kdeconnect/NetworkPacketTest.java
View File

@ -10,10 +10,7 @@ import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import android.content.Context;
import android.util.Log;
import org.json.JSONException;
@ -22,10 +19,13 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.kde.kdeconnect.Helpers.DeviceHelper;
import org.mockito.Mockito;
import org.mockito.internal.util.collections.Sets;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import java.security.cert.Certificate;
@RunWith(PowerMockRunner.class)
@PrepareForTest({DeviceHelper.class, Log.class})
public class NetworkPacketTest {
@ -34,7 +34,7 @@ public class NetworkPacketTest {
public void setUp() {
PowerMockito.mockStatic(DeviceHelper.class);
PowerMockito.when(DeviceHelper.getDeviceId(any())).thenReturn("123");
PowerMockito.when(DeviceHelper.getDeviceType(any())).thenReturn(Device.DeviceType.Phone);
PowerMockito.when(DeviceHelper.getDeviceType(any())).thenReturn(DeviceType.Phone);
PowerMockito.mockStatic(Log.class);
}
@ -70,14 +70,23 @@ public class NetworkPacketTest {
@Test
public void testIdentity() {
Certificate cert = Mockito.mock(Certificate.class);
Context context = Mockito.mock(Context.class);
MockSharedPreference settings = new MockSharedPreference();
Mockito.when(context.getSharedPreferences(anyString(), anyInt())).thenReturn(settings);
DeviceInfo deviceInfo = new DeviceInfo("myid", cert, "myname", DeviceType.Tv, 12, Sets.newSet("ASDFG"), Sets.newSet("QWERTY"));
NetworkPacket np = NetworkPacket.createIdentityPacket(context);
NetworkPacket np = deviceInfo.toIdentityPacket();
assertEquals(np.getInt("protocolVersion"), 12);
DeviceInfo parsed = DeviceInfo.fromIdentityPacketAndCert(np, cert);
assertEquals(parsed.name, deviceInfo.name);
assertEquals(parsed.id, deviceInfo.id);
assertEquals(parsed.type, deviceInfo.type);
assertEquals(parsed.protocolVersion, deviceInfo.protocolVersion);
assertEquals(parsed.incomingCapabilities, deviceInfo.incomingCapabilities);
assertEquals(parsed.outgoingCapabilities, deviceInfo.outgoingCapabilities);
assertEquals(np.getInt("protocolVersion"), DeviceHelper.ProtocolVersion);
}