From 4930a019d45cedea2c3d44149fcdfaf2a2a5d3c4 Mon Sep 17 00:00:00 2001 From: Albert Vaca Date: Wed, 31 Jul 2013 18:02:22 +0200 Subject: [PATCH] Added preferences and the ability to enable and disable plugins from there --- KdeConnect/src/main/AndroidManifest.xml | 10 +- .../org/kde/connect/BackgroundService.java | 149 ++++++++++++------ .../src/main/java/org/kde/connect/Device.java | 6 +- .../java/org/kde/connect/MainActivity.java | 12 ++ .../java/org/kde/connect/MprisActivity.java | 4 + .../BasePackageInterface.java | 7 +- .../BatteryMonitorPackageInterface.java | 70 ++++---- .../CallPackageInterface.java | 117 +++++++------- .../ClipboardPackageInterface.java | 52 +++--- .../MprisControlPackageInterface.java | 9 +- .../PingPackageInterface.java | 9 +- .../org/kde/connect/SettingsActivity.java | 21 +++ .../org/kde/connect/SettingsFragment.java | 50 ++++++ KdeConnect/src/main/res/values/strings.xml | 17 +- KdeConnect/src/main/res/xml/settings.xml | 36 +++++ 15 files changed, 408 insertions(+), 161 deletions(-) create mode 100644 KdeConnect/src/main/java/org/kde/connect/SettingsActivity.java create mode 100644 KdeConnect/src/main/java/org/kde/connect/SettingsFragment.java create mode 100644 KdeConnect/src/main/res/xml/settings.xml diff --git a/KdeConnect/src/main/AndroidManifest.xml b/KdeConnect/src/main/AndroidManifest.xml index 3a1fd2da..8e78a8ac 100644 --- a/KdeConnect/src/main/AndroidManifest.xml +++ b/KdeConnect/src/main/AndroidManifest.xml @@ -10,13 +10,13 @@ + android:label="KdeConnect " > @@ -26,9 +26,13 @@ + linkProviders = new ArrayList(); ArrayList packageInterfaces = new ArrayList(); HashMap devices = new HashMap(); - private void registerPackageInterfaces() { + public void registerLinkProviders() { + + SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(this); + + if (settings.getBoolean("avahitcp_link", true)) { + linkProviders.add(new AvahiTcpLinkProvider(this)); + } + } + + public void registerPackageInterfacesFromSettings() { + + SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(this); + + Log.e("registerPackageInterfacesFromSettings","registerPackageInterfacesFromSettings"); + if (settings.getBoolean("call_interface", true)) { - packageInterfaces.add(new CallPackageInterface(getApplicationContext())); + addPackageInterface(CallPackageInterface.class); + } else { + removePackageInterface(CallPackageInterface.class); } if (settings.getBoolean("ping_interface", true)) { - packageInterfaces.add(new PingPackageInterface(getApplicationContext())); + addPackageInterface(PingPackageInterface.class); + } else { + removePackageInterface(PingPackageInterface.class); } if (settings.getBoolean("clipboard_interface", true)) { - packageInterfaces.add(new ClipboardPackageInterface(getApplicationContext())); + addPackageInterface(ClipboardPackageInterface.class); + } else { + removePackageInterface(ClipboardPackageInterface.class); } if (settings.getBoolean("battery_interface", true)) { - packageInterfaces.add(new BatteryMonitorPackageInterface(getApplicationContext())); + addPackageInterface(BatteryMonitorPackageInterface.class); + } else { + removePackageInterface(BatteryMonitorPackageInterface.class); } if (settings.getBoolean("mpris_interface", true)) { - packageInterfaces.add(new MprisControlPackageInterface(getApplicationContext())); + addPackageInterface(MprisControlPackageInterface.class); + } else { + removePackageInterface(MprisControlPackageInterface.class); } - } public BasePackageInterface getPackageInterface(Class c) { @@ -62,12 +85,79 @@ public class BackgroundService extends Service { return null; } - public void registerLinkProviders() { - if (settings.getBoolean("avahitcp_link", true)) { - linkProviders.add(new AvahiTcpLinkProvider(this)); + public BasePackageInterface addPackageInterface(Class c) { + BasePackageInterface pi = getPackageInterface(c); + if (pi != null) { + Log.e("addPackageInterface","package interface already existent"); + return pi; } + try { + pi = (BasePackageInterface)c.newInstance(); + } catch(Exception e) { + e.printStackTrace(); + Log.e("addPackageInterface","Error instantiating packageinterface"); + return null; + } + packageInterfaces.add(pi); + pi.onCreate(getApplicationContext()); + for (Device dev : devices.values()) { + dev.addPackageReceiver(pi); + pi.addDevice(dev); + } + return pi; } + public boolean removePackageInterface(Class c) { + for (BasePackageInterface pi : packageInterfaces) { + if (c.isInstance(pi)) { + packageInterfaces.remove(pi); + for (Device dev : devices.values()) { + dev.removePackageReceiver(pi); + pi.removeDevice(dev); + } + pi.onDestroy(); + return true; + } + } + Log.e("removePackageInterface","Unexistent preference"); + return false; + } + + public Device getDevice(String id) { + return devices.get(id); + } + + private BaseLinkProvider.ConnectionReceiver deviceListener = new BaseLinkProvider.ConnectionReceiver() { + @Override + public void onConnectionAccepted(String deviceId, String name, BaseComputerLink link) { + Log.i("BackgroundService", "Connection accepted!"); + + if (devices.containsKey(deviceId)) { + Log.i("BackgroundService", "known device"); + devices.get(deviceId).addLink(link); + } else { + Log.i("BackgroundService", "unknown device"); + Device device = new Device(deviceId, name, link); + devices.put(deviceId, device); + for (BasePackageInterface pe : packageInterfaces) { + device.addPackageReceiver(pe); + pe.addDevice(device); + } + } + + } + + @Override + public void onConnectionLost(BaseComputerLink link) { + Device d = devices.get(link.getDeviceId()); + if (d != null) { + d.removeLink(link); + //if (d.countLinkedDevices() == 0) devices.remove(link.getDeviceId); + } + + } + }; + public ArrayList getVisibleDevices() { ArrayList list = new ArrayList(); for(Device d : devices.values()) { @@ -90,36 +180,7 @@ public class BackgroundService extends Service { private void startDiscovery() { Log.i("StartDiscovery","Registering connection receivers"); for (BaseLinkProvider a : linkProviders) { - a.reachComputers(new BaseLinkProvider.ConnectionReceiver() { - @Override - public void onConnectionAccepted(String deviceId, String name, BaseComputerLink link) { - Log.i("BackgroundService", "Connection accepted!"); - - if (devices.containsKey(deviceId)) { - Log.i("BackgroundService", "known device"); - devices.get(deviceId).addLink(link); - } else { - Log.i("BackgroundService", "unknown device"); - Device device = new Device(deviceId, name, link); - devices.put(deviceId, device); - for (BasePackageInterface pe : packageInterfaces) { - device.addPackageReceiver(pe); - pe.addDevice(device); - } - } - - } - - @Override - public void onConnectionLost(BaseComputerLink link) { - Device d = devices.get(link.getDeviceId()); - if (d != null) { - d.removeLink(link); - //if (d.countLinkedDevices() == 0) devices.remove(link.getDeviceId); - } - - } - }); + a.reachComputers(deviceListener); } } @@ -130,9 +191,7 @@ public class BackgroundService extends Service { Log.i("BackgroundService","Service not started yet, initializing..."); - settings = getSharedPreferences("KdeConnect", 0); - - registerPackageInterfaces(); + registerPackageInterfacesFromSettings(); registerLinkProviders(); startDiscovery(); diff --git a/KdeConnect/src/main/java/org/kde/connect/Device.java b/KdeConnect/src/main/java/org/kde/connect/Device.java index a1a8420e..9b70dc7c 100644 --- a/KdeConnect/src/main/java/org/kde/connect/Device.java +++ b/KdeConnect/src/main/java/org/kde/connect/Device.java @@ -67,6 +67,10 @@ public class Device { receivers.add(receiver); } + public void removePackageReceiver(BasePackageInterface receiver) { + receivers.remove(receiver); + } + public boolean sendPackage(final NetworkPackage np) { Log.e("Device", "sendPackage"); @@ -86,7 +90,7 @@ public class Device { } }.execute(); - return true; //FIXME + return true; //FIXME: Detect when unable to send a package and try again somehow } } diff --git a/KdeConnect/src/main/java/org/kde/connect/MainActivity.java b/KdeConnect/src/main/java/org/kde/connect/MainActivity.java index a353a442..c5a9c7f5 100644 --- a/KdeConnect/src/main/java/org/kde/connect/MainActivity.java +++ b/KdeConnect/src/main/java/org/kde/connect/MainActivity.java @@ -4,6 +4,7 @@ import android.app.Activity; import android.content.Intent; import android.os.Bundle; import android.view.Menu; +import android.view.MenuItem; import android.view.View; import android.view.View.OnClickListener; import android.widget.ArrayAdapter; @@ -94,4 +95,15 @@ public class MainActivity extends Activity { return true; } + @Override + public boolean onMenuItemSelected(int featureId, MenuItem item) { + switch(item.getItemId()){ + case R.id.action_settings: + Intent intent = new Intent(this,SettingsActivity.class); + startActivity(intent); + return true; + default: + return super.onMenuItemSelected(featureId, item); + } + } } diff --git a/KdeConnect/src/main/java/org/kde/connect/MprisActivity.java b/KdeConnect/src/main/java/org/kde/connect/MprisActivity.java index 914e8d30..e2cbf755 100644 --- a/KdeConnect/src/main/java/org/kde/connect/MprisActivity.java +++ b/KdeConnect/src/main/java/org/kde/connect/MprisActivity.java @@ -30,6 +30,7 @@ public class MprisActivity extends Activity { public void onServiceStart(BackgroundService service) { final MprisControlPackageInterface mpris = (MprisControlPackageInterface)service.getPackageInterface(MprisControlPackageInterface.class); + if (mpris == null) return; mpris.setNowPlayingUpdatedHandler(new Handler() { @Override @@ -84,6 +85,7 @@ public class MprisActivity extends Activity { @Override public void onServiceStart(BackgroundService service) { MprisControlPackageInterface mpris = (MprisControlPackageInterface)service.getPackageInterface(MprisControlPackageInterface.class); + if (mpris == null) return; mpris.sendAction("PlayPause"); } }); @@ -97,6 +99,7 @@ public class MprisActivity extends Activity { @Override public void onServiceStart(BackgroundService service) { MprisControlPackageInterface mpris = (MprisControlPackageInterface)service.getPackageInterface(MprisControlPackageInterface.class); + if (mpris == null) return; mpris.sendAction("Previous"); } }); @@ -110,6 +113,7 @@ public class MprisActivity extends Activity { @Override public void onServiceStart(BackgroundService service) { MprisControlPackageInterface mpris = (MprisControlPackageInterface)service.getPackageInterface(MprisControlPackageInterface.class); + if (mpris == null) return; mpris.sendAction("Next"); } }); diff --git a/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/BasePackageInterface.java b/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/BasePackageInterface.java index 31b166e8..03ddf4ac 100644 --- a/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/BasePackageInterface.java +++ b/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/BasePackageInterface.java @@ -1,5 +1,7 @@ package org.kde.connect.PackageInterfaces; +import android.content.Context; + import org.kde.connect.Device; import org.kde.connect.NetworkPackage; @@ -35,8 +37,9 @@ public abstract class BasePackageInterface { return true; } - //To override, returns true if package was handled + //To override + public abstract boolean onCreate(Context context); + public abstract void onDestroy(); public abstract boolean onPackageReceived(Device d, NetworkPackage np); - public abstract boolean onDeviceConnected(Device d); } diff --git a/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/BatteryMonitorPackageInterface.java b/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/BatteryMonitorPackageInterface.java index 6792d835..73683217 100644 --- a/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/BatteryMonitorPackageInterface.java +++ b/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/BatteryMonitorPackageInterface.java @@ -14,39 +14,51 @@ public class BatteryMonitorPackageInterface extends BasePackageInterface { NetworkPackage lastPackage = null; - public BatteryMonitorPackageInterface(final Context context) { - final IntentFilter ifilter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED); - context.registerReceiver(new BroadcastReceiver() { - @Override - public void onReceive(Context context, Intent intent) { + Context context; + IntentFilter filter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED); + BroadcastReceiver receiver = new BroadcastReceiver() { + @Override + public void onReceive(Context context, Intent intent) { - Log.e("BatteryMonitorPackageInterface", "Battery event"); + Log.e("BatteryMonitorPackageInterface", "Battery event"); - boolean isCharging = (0 != intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, 0)); + boolean isCharging = (0 != intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, 0)); - int currentCharge = 100; - int status = intent.getIntExtra(BatteryManager.EXTRA_STATUS, -1); - if (status != BatteryManager.BATTERY_STATUS_FULL) { - Intent batteryStatus = context.registerReceiver(null, ifilter); - int level = batteryStatus.getIntExtra(BatteryManager.EXTRA_LEVEL, -1); - int scale = batteryStatus.getIntExtra(BatteryManager.EXTRA_SCALE, -1); - currentCharge = level*100 / scale; - } - - //Only notify if change is meaningful enough - if (lastPackage == null || ( - isCharging != lastPackage.getBoolean("isCharging") - || currentCharge != lastPackage.getInt("currentCharge") - ) - ) { - NetworkPackage np = new NetworkPackage(NetworkPackage.PACKAGE_TYPE_BATTERY); - np.set("isCharging", isCharging); - np.set("currentCharge", currentCharge); - sendPackage(np); - lastPackage = np; - } + int currentCharge = 100; + int status = intent.getIntExtra(BatteryManager.EXTRA_STATUS, -1); + if (status != BatteryManager.BATTERY_STATUS_FULL) { + Intent batteryStatus = context.registerReceiver(null, filter); + int level = batteryStatus.getIntExtra(BatteryManager.EXTRA_LEVEL, -1); + int scale = batteryStatus.getIntExtra(BatteryManager.EXTRA_SCALE, -1); + currentCharge = level*100 / scale; } - }, ifilter); + + //Only notify if change is meaningful enough + if (lastPackage == null || ( + isCharging != lastPackage.getBoolean("isCharging") + || currentCharge != lastPackage.getInt("currentCharge") + ) + ) { + NetworkPackage np = new NetworkPackage(NetworkPackage.PACKAGE_TYPE_BATTERY); + np.set("isCharging", isCharging); + np.set("currentCharge", currentCharge); + sendPackage(np); + lastPackage = np; + } + + } + }; + + @Override + public boolean onCreate(final Context context) { + this.context = context; + context.registerReceiver(receiver, filter); + return true; + } + + @Override + public void onDestroy() { + context.unregisterReceiver(receiver); } @Override diff --git a/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/CallPackageInterface.java b/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/CallPackageInterface.java index 39e3bffd..1f73cd4f 100644 --- a/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/CallPackageInterface.java +++ b/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/CallPackageInterface.java @@ -11,38 +11,36 @@ import org.kde.connect.NetworkPackage; public class CallPackageInterface extends BasePackageInterface { - public CallPackageInterface(final Context ctx) { + private Context context; - //Log.i("CallPackageInterface", "Registered"); + private PhoneStateListener callStateListener = new PhoneStateListener() { - PhoneStateListener callStateListener = new PhoneStateListener() { + int lastState = TelephonyManager.CALL_STATE_IDLE; + NetworkPackage lastPackage = null; - int lastState = TelephonyManager.CALL_STATE_IDLE; - NetworkPackage lastPackage = null; + @Override + public void onCallStateChanged(int state, String phoneNumber) { - @Override - public void onCallStateChanged(int state, String phoneNumber) { + switch (state) { - switch (state) { + case TelephonyManager.CALL_STATE_RINGING: - case TelephonyManager.CALL_STATE_RINGING: + //Log.i("IncomingCall", ":" + phoneNumber); - //Log.i("IncomingCall", ":" + phoneNumber); + lastPackage = new NetworkPackage(NetworkPackage.PACKAGE_TYPE_NOTIFICATION); - lastPackage = new NetworkPackage(NetworkPackage.PACKAGE_TYPE_NOTIFICATION); + lastPackage.set("notificationType", "ringing"); + if (phoneNumber != null && !phoneNumber.isEmpty()) { + lastPackage.set("phoneNumber", phoneNumber); + } - lastPackage.set("notificationType", "ringing"); - if (phoneNumber != null && !phoneNumber.isEmpty()) { - lastPackage.set("phoneNumber", phoneNumber); - } + sendPackage(lastPackage); - sendPackage(lastPackage); + break; - break; + case TelephonyManager.CALL_STATE_OFFHOOK: //Ongoing call - case TelephonyManager.CALL_STATE_OFFHOOK: //Ongoing call - - //Log.i("OngoingCall", ":"+phoneNumber); + //Log.i("OngoingCall", ":"+phoneNumber); /* //Actually we do not want to cancel it @@ -53,51 +51,64 @@ public class CallPackageInterface extends BasePackageInterface { } */ - //Emit a "call" package - lastPackage = new NetworkPackage(NetworkPackage.PACKAGE_TYPE_CALL); - if (phoneNumber != null && !phoneNumber.isEmpty()) { - lastPackage.set("phoneNumber",phoneNumber); - } + //Emit a "call" package + lastPackage = new NetworkPackage(NetworkPackage.PACKAGE_TYPE_CALL); + if (phoneNumber != null && !phoneNumber.isEmpty()) { + lastPackage.set("phoneNumber",phoneNumber); + } + sendPackage(lastPackage); + + break; + + case TelephonyManager.CALL_STATE_IDLE: + + if (lastState != TelephonyManager.CALL_STATE_IDLE && lastPackage != null) { + + //Log.i("EndedCall", ":"+phoneNumber); + + //End last notification (can either be a ring notification or a call event) + lastPackage.set("isCancel","true"); sendPackage(lastPackage); - break; - - case TelephonyManager.CALL_STATE_IDLE: - - if (lastState != TelephonyManager.CALL_STATE_IDLE && lastPackage != null) { - - //Log.i("EndedCall", ":"+phoneNumber); - - //End last notification (can either be a ring notification or a call event) - lastPackage.set("isCancel","true"); - sendPackage(lastPackage); - - if (lastState == TelephonyManager.CALL_STATE_RINGING) { - //Emit a missed call notification - NetworkPackage missed = new NetworkPackage(NetworkPackage.PACKAGE_TYPE_NOTIFICATION); - missed.set("notificationType","missedCall"); - if (phoneNumber != null && !phoneNumber.isEmpty()) { - missed.set("phoneNumber", lastPackage.getString("phoneNumber")); - } - sendPackage(missed); + if (lastState == TelephonyManager.CALL_STATE_RINGING) { + //Emit a missed call notification + NetworkPackage missed = new NetworkPackage(NetworkPackage.PACKAGE_TYPE_NOTIFICATION); + missed.set("notificationType","missedCall"); + if (phoneNumber != null && !phoneNumber.isEmpty()) { + missed.set("phoneNumber", lastPackage.getString("phoneNumber")); } - - lastPackage = null; - + sendPackage(missed); } - break; + lastPackage = null; - } + } - lastState = state; + break; } - }; - TelephonyManager tm = (TelephonyManager) ctx.getSystemService(Context.TELEPHONY_SERVICE); + lastState = state; + + } + }; + + @Override + public boolean onCreate(final Context context) { + + this.context = context; + + TelephonyManager tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); tm.listen(callStateListener, PhoneStateListener.LISTEN_CALL_STATE); + return true; + + } + + @Override + public void onDestroy() { + TelephonyManager tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); + tm.listen(callStateListener, PhoneStateListener.LISTEN_NONE); } @Override diff --git a/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/ClipboardPackageInterface.java b/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/ClipboardPackageInterface.java index fb4e5c72..edd8bb80 100644 --- a/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/ClipboardPackageInterface.java +++ b/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/ClipboardPackageInterface.java @@ -9,31 +9,43 @@ import org.kde.connect.NetworkPackage; public class ClipboardPackageInterface extends BasePackageInterface { - ClipboardManager cm; boolean ignore_next_clipboard_change = false; - public ClipboardPackageInterface(final Context ctx) { - - cm = (ClipboardManager)ctx.getSystemService(Context.CLIPBOARD_SERVICE); - - cm.addPrimaryClipChangedListener(new ClipboardManager.OnPrimaryClipChangedListener() { - @Override - public void onPrimaryClipChanged() { - try { - if (ignore_next_clipboard_change) { - ignore_next_clipboard_change = false; - return; - } - NetworkPackage np = new NetworkPackage(NetworkPackage.PACKAGE_TYPE_CLIPBOARD); - ClipData.Item item = cm.getPrimaryClip().getItemAt(0); - np.set("content",item.coerceToText(ctx).toString()); - sendPackage(np); - } catch(Exception e) { - //Probably clipboard was not text + Context context; + ClipboardManager cm; + ClipboardManager.OnPrimaryClipChangedListener listener = new ClipboardManager.OnPrimaryClipChangedListener() { + @Override + public void onPrimaryClipChanged() { + try { + if (ignore_next_clipboard_change) { + ignore_next_clipboard_change = false; + return; } + NetworkPackage np = new NetworkPackage(NetworkPackage.PACKAGE_TYPE_CLIPBOARD); + ClipData.Item item = cm.getPrimaryClip().getItemAt(0); + np.set("content",item.coerceToText(context).toString()); + sendPackage(np); + } catch(Exception e) { + //Probably clipboard was not text } - }); + } + }; + @Override + public boolean onCreate(Context context) { + + this.context = context; + + cm = (ClipboardManager)context.getSystemService(Context.CLIPBOARD_SERVICE); + cm.addPrimaryClipChangedListener(listener); + + return false; + + } + + @Override + public void onDestroy() { + cm.removePrimaryClipChangedListener(listener); } @Override diff --git a/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/MprisControlPackageInterface.java b/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/MprisControlPackageInterface.java index 5a65cd58..fe46fe55 100644 --- a/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/MprisControlPackageInterface.java +++ b/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/MprisControlPackageInterface.java @@ -26,8 +26,15 @@ public class MprisControlPackageInterface extends BasePackageInterface { String player = ""; - public MprisControlPackageInterface(Context ctx) { + @Override + public boolean onCreate(Context ctx) { context = ctx; + return true; + } + + @Override + public void onDestroy() { + playerList.clear(); } public void sendAction(String s) { diff --git a/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/PingPackageInterface.java b/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/PingPackageInterface.java index c0773734..0df6c11c 100644 --- a/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/PingPackageInterface.java +++ b/KdeConnect/src/main/java/org/kde/connect/PackageInterfaces/PingPackageInterface.java @@ -14,8 +14,15 @@ public class PingPackageInterface extends BasePackageInterface { Context context; - public PingPackageInterface(Context ctx) { + @Override + public boolean onCreate(Context ctx) { context = ctx; + return true; + } + + @Override + public void onDestroy() { + } public void sendPing() { diff --git a/KdeConnect/src/main/java/org/kde/connect/SettingsActivity.java b/KdeConnect/src/main/java/org/kde/connect/SettingsActivity.java new file mode 100644 index 00000000..51df8ebc --- /dev/null +++ b/KdeConnect/src/main/java/org/kde/connect/SettingsActivity.java @@ -0,0 +1,21 @@ +package org.kde.connect; + +import android.app.Activity; +import android.os.Bundle; + + +public class SettingsActivity extends Activity { + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + // Display the fragment as the main content. + getFragmentManager().beginTransaction() + .replace(android.R.id.content, new SettingsFragment()) + .commit(); + + } + + +} diff --git a/KdeConnect/src/main/java/org/kde/connect/SettingsFragment.java b/KdeConnect/src/main/java/org/kde/connect/SettingsFragment.java new file mode 100644 index 00000000..0ccaabeb --- /dev/null +++ b/KdeConnect/src/main/java/org/kde/connect/SettingsFragment.java @@ -0,0 +1,50 @@ +package org.kde.connect; + +import android.app.Activity; +import android.content.SharedPreferences; +import android.os.Bundle; +import android.preference.PreferenceFragment; +import android.util.Log; + +import org.kde.kdeconnect.R; + +public class SettingsFragment extends PreferenceFragment { + + SharedPreferences.OnSharedPreferenceChangeListener preferenceChangeListener = new SharedPreferences.OnSharedPreferenceChangeListener() { + @Override + public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { + + Log.e("onSharedPreferenceChanged",key+"->"+sharedPreferences.getBoolean(key,true)); + Activity activity = getActivity(); + if (activity == null) return; + BackgroundService.RunCommand(activity, new BackgroundService.InstanceCallback() { + @Override + public void onServiceStart(BackgroundService service) { + service.registerPackageInterfacesFromSettings(); + } + }); + } + }; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + addPreferencesFromResource(R.xml.settings); + } + + @Override + public void onResume() { + super.onResume(); + getPreferenceManager().getSharedPreferences() + .registerOnSharedPreferenceChangeListener(preferenceChangeListener); + + } + + @Override + public void onPause() { + getPreferenceManager().getSharedPreferences() + .unregisterOnSharedPreferenceChangeListener(preferenceChangeListener); + super.onPause(); + } + +} \ No newline at end of file diff --git a/KdeConnect/src/main/res/values/strings.xml b/KdeConnect/src/main/res/values/strings.xml index f806d88f..d10516e8 100644 --- a/KdeConnect/src/main/res/values/strings.xml +++ b/KdeConnect/src/main/res/values/strings.xml @@ -1,11 +1,16 @@ - KdeConnect - - Settings - - Hello world! - + Settings + Call notifications + Send incoming and missed call notifications + Clipboard sync + Share the clipboard content + Battery report + Periodically report battery status + MPRIS controls + Control audio/video from your phone + Pings + Enable sending and receiving ping notifications diff --git a/KdeConnect/src/main/res/xml/settings.xml b/KdeConnect/src/main/res/xml/settings.xml new file mode 100644 index 00000000..71210111 --- /dev/null +++ b/KdeConnect/src/main/res/xml/settings.xml @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + \ No newline at end of file