From a8950597d021cbdfaa38e899afde33ada6edcc10 Mon Sep 17 00:00:00 2001 From: jens Date: Tue, 16 Feb 2021 13:42:49 +0100 Subject: [PATCH] Initial commit --- .gitignore | 150 ++ .idea/.gitignore | 3 + app/.gitignore | 150 ++ app/build.gradle | 79 + app/proguard-rules.pro | 21 + .../automation2/ExampleInstrumentedTest.java | 28 + app/src/apkFlavor/AndroidManifest.xml | 203 ++ app/src/fdroidFlavor/AndroidManifest.xml | 187 ++ app/src/google-services.json | 48 + app/src/googlePlayFlavor/AndroidManifest.xml | 203 ++ app/src/main/AndroidManifest.xml | 192 ++ .../java/com/jens/automation2/AESCrypt.java | 200 ++ .../java/com/jens/automation2/Action.java | 537 +++++ .../java/com/jens/automation2/Actions.java | 1192 +++++++++++ .../ActivityEditSendTextMessage.java | 181 ++ .../automation2/ActivityEditSpeakText.java | 76 + .../automation2/ActivityEditTriggerUrl.java | 171 ++ .../com/jens/automation2/ActivityGeneric.java | 67 + .../com/jens/automation2/ActivityHelp.java | 23 + .../com/jens/automation2/ActivityMainPoi.java | 201 ++ .../automation2/ActivityMainProfiles.java | 198 ++ .../jens/automation2/ActivityMainRules.java | 252 +++ .../jens/automation2/ActivityMainScreen.java | 600 ++++++ .../automation2/ActivityMainTabLayout.java | 70 + .../ActivityManageBluetoothTrigger.java | 187 ++ .../ActivityManageBrightnessSetting.java | 64 + .../jens/automation2/ActivityManageNfc.java | 306 +++ .../ActivityManageSpecificPoi.java | 476 +++++ .../ActivityManageSpecificProfile.java | 487 +++++ .../ActivityManageSpecificRule.java | 1674 ++++++++++++++++ .../ActivityManageStartActivity.java | 500 +++++ .../automation2/ActivityManageTimeFrame.java | 163 ++ .../jens/automation2/ActivityPermissions.java | 1370 +++++++++++++ .../jens/automation2/ActivitySettings.java | 19 + .../jens/automation2/ActivityVolumeTest.java | 210 ++ .../jens/automation2/AutomationService.java | 713 +++++++ .../CompensateCrappyAndroidPaths.java | 371 ++++ .../com/jens/automation2/Miscellaneous.java | 887 +++++++++ .../com/jens/automation2/MyHttpClient.java | 57 + .../MySSLSocketFactoryInsecure.java | 57 + .../com/jens/automation2/PointOfInterest.java | 825 ++++++++ .../java/com/jens/automation2/Profile.java | 543 +++++ .../jens/automation2/ReceiverCoordinator.java | 277 +++ .../main/java/com/jens/automation2/Rule.java | 1425 +++++++++++++ .../java/com/jens/automation2/Settings.java | 503 +++++ .../java/com/jens/automation2/TimeFrame.java | 75 + .../java/com/jens/automation2/Trigger.java | 479 +++++ .../jens/automation2/XmlFileInterface.java | 1301 ++++++++++++ .../location/CellLocationChangedReceiver.java | 407 ++++ .../location/GeofenceBroadcastReceiver.java | 54 + .../location/GeofenceIntentService.java | 109 + .../location/LocationProvider.java | 506 +++++ .../automation2/location/SensorActivity.java | 220 +++ .../location/WifiBroadcastReceiver.java | 229 +++ .../receivers/ActivityDetectionReceiver.java | 400 ++++ .../automation2/receivers/AlarmListener.java | 301 +++ .../AutomationListenerInterface.java | 12 + .../receivers/BatteryReceiver.java | 314 +++ .../receivers/BluetoothReceiver.java | 303 +++ .../receivers/ConnectivityReceiver.java | 263 +++ .../receivers/HeadphoneJackListener.java | 152 ++ .../automation2/receivers/NfcReceiver.java | 344 ++++ .../automation2/receivers/NoiseListener.java | 215 ++ .../receivers/PackageReplacedReceiver.java | 56 + .../receivers/PhoneStatusListener.java | 331 ++++ .../receivers/ProcessListener.java | 470 +++++ .../receivers/StartupIntentReceiver.java | 34 + .../receivers/TimeZoneListener.java | 114 ++ .../chainfire/libsuperuser/Application.java | 80 + .../java/eu/chainfire/libsuperuser/Debug.java | 242 +++ .../libsuperuser/HideOverlaysReceiver.java | 59 + .../java/eu/chainfire/libsuperuser/Shell.java | 1757 +++++++++++++++++ .../libsuperuser/ShellNotClosedException.java | 29 + .../ShellOnMainThreadException.java | 32 + .../chainfire/libsuperuser/StreamGobbler.java | 105 + .../res/drawable-hdpi/activitydetection.png | Bin 0 -> 2835 bytes app/src/main/res/drawable-hdpi/alarm.png | Bin 0 -> 2406 bytes app/src/main/res/drawable-hdpi/battery.png | Bin 0 -> 2762 bytes app/src/main/res/drawable-hdpi/bluetooth.png | Bin 0 -> 1536 bytes app/src/main/res/drawable-hdpi/brightness.png | Bin 0 -> 1554 bytes app/src/main/res/drawable-hdpi/compass.png | Bin 0 -> 20686 bytes .../main/res/drawable-hdpi/compass_small.png | Bin 0 -> 3396 bytes app/src/main/res/drawable-hdpi/contacts.png | Bin 0 -> 2824 bytes .../main/res/drawable-hdpi/dataconnection.png | Bin 0 -> 3126 bytes .../res/drawable-hdpi/displayrotation.png | Bin 0 -> 1312 bytes app/src/main/res/drawable-hdpi/ear.png | Bin 0 -> 2312 bytes app/src/main/res/drawable-hdpi/gear.png | Bin 0 -> 61619 bytes app/src/main/res/drawable-hdpi/gears.png | Bin 0 -> 867418 bytes app/src/main/res/drawable-hdpi/headphone.png | Bin 0 -> 1515 bytes app/src/main/res/drawable-hdpi/help.png | Bin 0 -> 2122 bytes app/src/main/res/drawable-hdpi/home.png | Bin 0 -> 7792 bytes .../res/drawable-hdpi/ic_action_search.png | Bin 0 -> 3120 bytes .../main/res/drawable-hdpi/ic_launcher.png | Bin 0 -> 2864 bytes .../res/drawable-hdpi/icon_overview_tab.xml | 8 + .../main/res/drawable-hdpi/icon_poi_tab.xml | 8 + .../main/res/drawable-hdpi/icon_rules_tab.xml | 8 + app/src/main/res/drawable-hdpi/map.png | Bin 0 -> 6389 bytes app/src/main/res/drawable-hdpi/message.png | Bin 0 -> 2258 bytes app/src/main/res/drawable-hdpi/nfc.png | Bin 0 -> 2923 bytes app/src/main/res/drawable-hdpi/phone.png | Bin 0 -> 1387 bytes .../main/res/drawable-hdpi/placeholder.png | Bin 0 -> 228 bytes app/src/main/res/drawable-hdpi/plane.png | Bin 0 -> 1295 bytes app/src/main/res/drawable-hdpi/power.png | Bin 0 -> 2113 bytes app/src/main/res/drawable-hdpi/roaming.png | Bin 0 -> 2327 bytes app/src/main/res/drawable-hdpi/router.png | Bin 0 -> 1503 bytes app/src/main/res/drawable-hdpi/rule.png | Bin 0 -> 39978 bytes app/src/main/res/drawable-hdpi/sound.png | Bin 0 -> 3072 bytes app/src/main/res/drawable-hdpi/speed.png | Bin 0 -> 5276 bytes app/src/main/res/drawable-hdpi/speedlimit.png | Bin 0 -> 5055 bytes .../main/res/drawable-hdpi/startprogram.png | Bin 0 -> 2683 bytes .../main/res/drawable-hdpi/status_active.png | Bin 0 -> 412 bytes .../res/drawable-hdpi/status_inactive.png | Bin 0 -> 337 bytes .../main/res/drawable-hdpi/status_unable.png | Bin 0 -> 366 bytes app/src/main/res/drawable-hdpi/talking.png | Bin 0 -> 1644 bytes app/src/main/res/drawable-hdpi/triggerurl.png | Bin 0 -> 4241 bytes app/src/main/res/drawable-hdpi/tune.png | Bin 0 -> 1473 bytes app/src/main/res/drawable-hdpi/usb.png | Bin 0 -> 5903 bytes app/src/main/res/drawable-hdpi/wait.png | Bin 0 -> 3052 bytes app/src/main/res/drawable-hdpi/wifi.png | Bin 0 -> 1870 bytes app/src/main/res/drawable-ldpi/gears.png | Bin 0 -> 867418 bytes .../main/res/drawable-ldpi/ic_launcher.png | Bin 0 -> 1418 bytes app/src/main/res/drawable-mdpi/cancel.png | Bin 0 -> 380 bytes .../res/drawable-mdpi/ic_action_search.png | Bin 0 -> 3030 bytes .../main/res/drawable-mdpi/ic_launcher.png | Bin 0 -> 1859 bytes app/src/main/res/drawable-mdpi/priority.png | Bin 0 -> 140 bytes .../drawable-v24/ic_launcher_foreground.xml | 30 + .../res/drawable-xhdpi/ic_action_search.png | Bin 0 -> 3199 bytes .../main/res/drawable-xhdpi/ic_launcher.png | Bin 0 -> 3827 bytes .../res/drawable/ic_launcher_background.xml | 170 ++ .../main/res/layout/action_start_activity.xml | 117 ++ .../res/layout/activity_bluetooth_trigger.xml | 104 + .../activity_manage_brightness_setting.xml | 32 + .../main/res/layout/activity_volume_test.xml | 70 + app/src/main/res/layout/alert_customlist.xml | 25 + app/src/main/res/layout/help_text.xml | 244 +++ .../main/res/layout/main_overview_layout.xml | 333 ++++ app/src/main/res/layout/main_poi_layout.xml | 61 + .../main/res/layout/main_profile_layout.xml | 67 + app/src/main/res/layout/main_rule_layout.xml | 77 + app/src/main/res/layout/main_tab_layout.xml | 19 + app/src/main/res/layout/manage_nfc.xml | 134 ++ .../main/res/layout/manage_specific_poi.xml | 148 ++ .../res/layout/manage_specific_profile.xml | 252 +++ .../main/res/layout/manage_specific_rule.xml | 191 ++ .../main/res/layout/permissions_activity.xml | 116 ++ .../res/layout/send_textmessage_editor.xml | 72 + app/src/main/res/layout/settings.xml | 267 +++ app/src/main/res/layout/speak_text_editor.xml | 51 + ...xt_view_for_poi_listview_largetextsize.xml | 8 + ...t_view_for_poi_listview_mediumtextsize.xml | 8 + ...xt_view_for_poi_listview_smalltextsize.xml | 8 + .../text_view_for_ring_mode_spinner.xml | 8 + .../res/layout/trigger_timeframe_editor.xml | 131 ++ .../main/res/layout/trigger_url_editor.xml | 114 ++ .../res/layout/view_for_rule_listview.xml | 24 + app/src/main/res/menu/activity_main.xml | 5 + .../res/mipmap-anydpi-v26/ic_launcher.xml | 5 + .../mipmap-anydpi-v26/ic_launcher_round.xml | 5 + app/src/main/res/mipmap-hdpi/ic_launcher.png | Bin 0 -> 3593 bytes .../res/mipmap-hdpi/ic_launcher_round.png | Bin 0 -> 5339 bytes app/src/main/res/mipmap-mdpi/ic_launcher.png | Bin 0 -> 2636 bytes .../res/mipmap-mdpi/ic_launcher_round.png | Bin 0 -> 3388 bytes app/src/main/res/mipmap-xhdpi/ic_launcher.png | Bin 0 -> 4926 bytes .../res/mipmap-xhdpi/ic_launcher_round.png | Bin 0 -> 7472 bytes .../main/res/mipmap-xxhdpi/ic_launcher.png | Bin 0 -> 7909 bytes .../res/mipmap-xxhdpi/ic_launcher_round.png | Bin 0 -> 11873 bytes .../main/res/mipmap-xxxhdpi/ic_launcher.png | Bin 0 -> 10652 bytes .../res/mipmap-xxxhdpi/ic_launcher_round.png | Bin 0 -> 16570 bytes app/src/main/res/raw/keystore.ks | Bin 0 -> 1881 bytes app/src/main/res/values-de/strings.xml | 596 ++++++ app/src/main/res/values-es/strings.xml | 577 ++++++ app/src/main/res/values-it/strings.xml | 569 ++++++ app/src/main/res/values-night/themes.xml | 16 + app/src/main/res/values-w820dp/dimens.xml | 6 + app/src/main/res/values/arrays.xml | 24 + app/src/main/res/values/colors.xml | 13 + app/src/main/res/values/dimens.xml | 6 + app/src/main/res/values/strings.xml | 600 ++++++ app/src/main/res/values/styles.xml | 5 + app/src/main/res/values/themes.xml | 16 + .../main/res/xml/network_security_config.xml | 10 + app/src/main/res/xml/nfc_tech_filter.xml | 23 + .../com/jens/automation2/ExampleUnitTest.java | 19 + build.gradle | 24 + gradle.properties | 19 + gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 54329 bytes gradle/wrapper/gradle-wrapper.properties | 6 + gradlew | 172 ++ gradlew.bat | 84 + settings.gradle | 2 + 190 files changed, 30846 insertions(+) create mode 100644 .gitignore create mode 100644 .idea/.gitignore create mode 100644 app/.gitignore create mode 100644 app/build.gradle create mode 100644 app/proguard-rules.pro create mode 100644 app/src/androidTest/java/com/jens/automation2/ExampleInstrumentedTest.java create mode 100644 app/src/apkFlavor/AndroidManifest.xml create mode 100644 app/src/fdroidFlavor/AndroidManifest.xml create mode 100644 app/src/google-services.json create mode 100644 app/src/googlePlayFlavor/AndroidManifest.xml create mode 100644 app/src/main/AndroidManifest.xml create mode 100644 app/src/main/java/com/jens/automation2/AESCrypt.java create mode 100644 app/src/main/java/com/jens/automation2/Action.java create mode 100644 app/src/main/java/com/jens/automation2/Actions.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityEditSendTextMessage.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityEditSpeakText.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityEditTriggerUrl.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityGeneric.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityHelp.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityMainPoi.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityMainProfiles.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityMainRules.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityMainScreen.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityMainTabLayout.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityManageBluetoothTrigger.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityManageBrightnessSetting.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityManageNfc.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityManageSpecificPoi.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityManageSpecificProfile.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityManageSpecificRule.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityManageStartActivity.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityManageTimeFrame.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityPermissions.java create mode 100644 app/src/main/java/com/jens/automation2/ActivitySettings.java create mode 100644 app/src/main/java/com/jens/automation2/ActivityVolumeTest.java create mode 100644 app/src/main/java/com/jens/automation2/AutomationService.java create mode 100644 app/src/main/java/com/jens/automation2/CompensateCrappyAndroidPaths.java create mode 100644 app/src/main/java/com/jens/automation2/Miscellaneous.java create mode 100644 app/src/main/java/com/jens/automation2/MyHttpClient.java create mode 100644 app/src/main/java/com/jens/automation2/MySSLSocketFactoryInsecure.java create mode 100644 app/src/main/java/com/jens/automation2/PointOfInterest.java create mode 100644 app/src/main/java/com/jens/automation2/Profile.java create mode 100644 app/src/main/java/com/jens/automation2/ReceiverCoordinator.java create mode 100644 app/src/main/java/com/jens/automation2/Rule.java create mode 100644 app/src/main/java/com/jens/automation2/Settings.java create mode 100644 app/src/main/java/com/jens/automation2/TimeFrame.java create mode 100644 app/src/main/java/com/jens/automation2/Trigger.java create mode 100644 app/src/main/java/com/jens/automation2/XmlFileInterface.java create mode 100644 app/src/main/java/com/jens/automation2/location/CellLocationChangedReceiver.java create mode 100644 app/src/main/java/com/jens/automation2/location/GeofenceBroadcastReceiver.java create mode 100644 app/src/main/java/com/jens/automation2/location/GeofenceIntentService.java create mode 100644 app/src/main/java/com/jens/automation2/location/LocationProvider.java create mode 100644 app/src/main/java/com/jens/automation2/location/SensorActivity.java create mode 100644 app/src/main/java/com/jens/automation2/location/WifiBroadcastReceiver.java create mode 100644 app/src/main/java/com/jens/automation2/receivers/ActivityDetectionReceiver.java create mode 100644 app/src/main/java/com/jens/automation2/receivers/AlarmListener.java create mode 100644 app/src/main/java/com/jens/automation2/receivers/AutomationListenerInterface.java create mode 100644 app/src/main/java/com/jens/automation2/receivers/BatteryReceiver.java create mode 100644 app/src/main/java/com/jens/automation2/receivers/BluetoothReceiver.java create mode 100644 app/src/main/java/com/jens/automation2/receivers/ConnectivityReceiver.java create mode 100644 app/src/main/java/com/jens/automation2/receivers/HeadphoneJackListener.java create mode 100644 app/src/main/java/com/jens/automation2/receivers/NfcReceiver.java create mode 100644 app/src/main/java/com/jens/automation2/receivers/NoiseListener.java create mode 100644 app/src/main/java/com/jens/automation2/receivers/PackageReplacedReceiver.java create mode 100644 app/src/main/java/com/jens/automation2/receivers/PhoneStatusListener.java create mode 100644 app/src/main/java/com/jens/automation2/receivers/ProcessListener.java create mode 100644 app/src/main/java/com/jens/automation2/receivers/StartupIntentReceiver.java create mode 100644 app/src/main/java/com/jens/automation2/receivers/TimeZoneListener.java create mode 100644 app/src/main/java/eu/chainfire/libsuperuser/Application.java create mode 100644 app/src/main/java/eu/chainfire/libsuperuser/Debug.java create mode 100644 app/src/main/java/eu/chainfire/libsuperuser/HideOverlaysReceiver.java create mode 100644 app/src/main/java/eu/chainfire/libsuperuser/Shell.java create mode 100644 app/src/main/java/eu/chainfire/libsuperuser/ShellNotClosedException.java create mode 100644 app/src/main/java/eu/chainfire/libsuperuser/ShellOnMainThreadException.java create mode 100644 app/src/main/java/eu/chainfire/libsuperuser/StreamGobbler.java create mode 100644 app/src/main/res/drawable-hdpi/activitydetection.png create mode 100644 app/src/main/res/drawable-hdpi/alarm.png create mode 100644 app/src/main/res/drawable-hdpi/battery.png create mode 100644 app/src/main/res/drawable-hdpi/bluetooth.png create mode 100644 app/src/main/res/drawable-hdpi/brightness.png create mode 100644 app/src/main/res/drawable-hdpi/compass.png create mode 100644 app/src/main/res/drawable-hdpi/compass_small.png create mode 100644 app/src/main/res/drawable-hdpi/contacts.png create mode 100644 app/src/main/res/drawable-hdpi/dataconnection.png create mode 100644 app/src/main/res/drawable-hdpi/displayrotation.png create mode 100644 app/src/main/res/drawable-hdpi/ear.png create mode 100644 app/src/main/res/drawable-hdpi/gear.png create mode 100644 app/src/main/res/drawable-hdpi/gears.png create mode 100644 app/src/main/res/drawable-hdpi/headphone.png create mode 100644 app/src/main/res/drawable-hdpi/help.png create mode 100644 app/src/main/res/drawable-hdpi/home.png create mode 100644 app/src/main/res/drawable-hdpi/ic_action_search.png create mode 100644 app/src/main/res/drawable-hdpi/ic_launcher.png create mode 100644 app/src/main/res/drawable-hdpi/icon_overview_tab.xml create mode 100644 app/src/main/res/drawable-hdpi/icon_poi_tab.xml create mode 100644 app/src/main/res/drawable-hdpi/icon_rules_tab.xml create mode 100644 app/src/main/res/drawable-hdpi/map.png create mode 100644 app/src/main/res/drawable-hdpi/message.png create mode 100644 app/src/main/res/drawable-hdpi/nfc.png create mode 100644 app/src/main/res/drawable-hdpi/phone.png create mode 100644 app/src/main/res/drawable-hdpi/placeholder.png create mode 100644 app/src/main/res/drawable-hdpi/plane.png create mode 100644 app/src/main/res/drawable-hdpi/power.png create mode 100644 app/src/main/res/drawable-hdpi/roaming.png create mode 100644 app/src/main/res/drawable-hdpi/router.png create mode 100644 app/src/main/res/drawable-hdpi/rule.png create mode 100644 app/src/main/res/drawable-hdpi/sound.png create mode 100644 app/src/main/res/drawable-hdpi/speed.png create mode 100644 app/src/main/res/drawable-hdpi/speedlimit.png create mode 100644 app/src/main/res/drawable-hdpi/startprogram.png create mode 100644 app/src/main/res/drawable-hdpi/status_active.png create mode 100644 app/src/main/res/drawable-hdpi/status_inactive.png create mode 100644 app/src/main/res/drawable-hdpi/status_unable.png create mode 100644 app/src/main/res/drawable-hdpi/talking.png create mode 100644 app/src/main/res/drawable-hdpi/triggerurl.png create mode 100644 app/src/main/res/drawable-hdpi/tune.png create mode 100644 app/src/main/res/drawable-hdpi/usb.png create mode 100644 app/src/main/res/drawable-hdpi/wait.png create mode 100644 app/src/main/res/drawable-hdpi/wifi.png create mode 100644 app/src/main/res/drawable-ldpi/gears.png create mode 100644 app/src/main/res/drawable-ldpi/ic_launcher.png create mode 100644 app/src/main/res/drawable-mdpi/cancel.png create mode 100644 app/src/main/res/drawable-mdpi/ic_action_search.png create mode 100644 app/src/main/res/drawable-mdpi/ic_launcher.png create mode 100644 app/src/main/res/drawable-mdpi/priority.png create mode 100644 app/src/main/res/drawable-v24/ic_launcher_foreground.xml create mode 100644 app/src/main/res/drawable-xhdpi/ic_action_search.png create mode 100644 app/src/main/res/drawable-xhdpi/ic_launcher.png create mode 100644 app/src/main/res/drawable/ic_launcher_background.xml create mode 100644 app/src/main/res/layout/action_start_activity.xml create mode 100644 app/src/main/res/layout/activity_bluetooth_trigger.xml create mode 100644 app/src/main/res/layout/activity_manage_brightness_setting.xml create mode 100644 app/src/main/res/layout/activity_volume_test.xml create mode 100644 app/src/main/res/layout/alert_customlist.xml create mode 100644 app/src/main/res/layout/help_text.xml create mode 100644 app/src/main/res/layout/main_overview_layout.xml create mode 100644 app/src/main/res/layout/main_poi_layout.xml create mode 100644 app/src/main/res/layout/main_profile_layout.xml create mode 100644 app/src/main/res/layout/main_rule_layout.xml create mode 100644 app/src/main/res/layout/main_tab_layout.xml create mode 100644 app/src/main/res/layout/manage_nfc.xml create mode 100644 app/src/main/res/layout/manage_specific_poi.xml create mode 100644 app/src/main/res/layout/manage_specific_profile.xml create mode 100644 app/src/main/res/layout/manage_specific_rule.xml create mode 100644 app/src/main/res/layout/permissions_activity.xml create mode 100644 app/src/main/res/layout/send_textmessage_editor.xml create mode 100644 app/src/main/res/layout/settings.xml create mode 100644 app/src/main/res/layout/speak_text_editor.xml create mode 100644 app/src/main/res/layout/text_view_for_poi_listview_largetextsize.xml create mode 100644 app/src/main/res/layout/text_view_for_poi_listview_mediumtextsize.xml create mode 100644 app/src/main/res/layout/text_view_for_poi_listview_smalltextsize.xml create mode 100644 app/src/main/res/layout/text_view_for_ring_mode_spinner.xml create mode 100644 app/src/main/res/layout/trigger_timeframe_editor.xml create mode 100644 app/src/main/res/layout/trigger_url_editor.xml create mode 100644 app/src/main/res/layout/view_for_rule_listview.xml create mode 100644 app/src/main/res/menu/activity_main.xml create mode 100644 app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml create mode 100644 app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml create mode 100644 app/src/main/res/mipmap-hdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-hdpi/ic_launcher_round.png create mode 100644 app/src/main/res/mipmap-mdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-mdpi/ic_launcher_round.png create mode 100644 app/src/main/res/mipmap-xhdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-xhdpi/ic_launcher_round.png create mode 100644 app/src/main/res/mipmap-xxhdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png create mode 100644 app/src/main/res/mipmap-xxxhdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png create mode 100644 app/src/main/res/raw/keystore.ks create mode 100644 app/src/main/res/values-de/strings.xml create mode 100644 app/src/main/res/values-es/strings.xml create mode 100644 app/src/main/res/values-it/strings.xml create mode 100644 app/src/main/res/values-night/themes.xml create mode 100644 app/src/main/res/values-w820dp/dimens.xml create mode 100644 app/src/main/res/values/arrays.xml create mode 100644 app/src/main/res/values/colors.xml create mode 100644 app/src/main/res/values/dimens.xml create mode 100644 app/src/main/res/values/strings.xml create mode 100644 app/src/main/res/values/styles.xml create mode 100644 app/src/main/res/values/themes.xml create mode 100644 app/src/main/res/xml/network_security_config.xml create mode 100644 app/src/main/res/xml/nfc_tech_filter.xml create mode 100644 app/src/test/java/com/jens/automation2/ExampleUnitTest.java create mode 100644 build.gradle create mode 100644 gradle.properties create mode 100644 gradle/wrapper/gradle-wrapper.jar create mode 100644 gradle/wrapper/gradle-wrapper.properties create mode 100644 gradlew create mode 100644 gradlew.bat create mode 100644 settings.gradle diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..74284c4 --- /dev/null +++ b/.gitignore @@ -0,0 +1,150 @@ + +# Created by https://www.toptal.com/developers/gitignore/api/androidstudio +# Edit at https://www.toptal.com/developers/gitignore?templates=androidstudio + +### AndroidStudio ### +# Covers files to be ignored for android development using Android Studio. + +# Built application files +*.apk +*.ap_ +*.aab + +# Files for the ART/Dalvik VM +*.dex + +# Java class files +*.class + +# Generated files +bin/ +gen/ +out/ + +# Gradle files +.gradle +.gradle/ +build/ + +# Signing files +.signing/ + +# Local configuration file (sdk path, etc) +local.properties + +# Proguard folder generated by Eclipse +proguard/ + +# Log Files +*.log + +# Android Studio +/*/build/ +/*/local.properties +/*/out +/*/*/build +/*/*/production +captures/ +.navigation/ +*.ipr +*~ +*.swp + +# Keystore files +*.jks +*.keystore + +# Google Services (e.g. APIs or Firebase) +# google-services.json + +# Android Patch +gen-external-apklibs + +# External native build folder generated in Android Studio 2.2 and later +.externalNativeBuild + +# NDK +obj/ + +# IntelliJ IDEA +*.iml +*.iws +/out/ + +# User-specific configurations +.idea/caches/ +.idea/libraries/ +.idea/shelf/ +.idea/workspace.xml +.idea/tasks.xml +.idea/.name +.idea/compiler.xml +.idea/copyright/profiles_settings.xml +.idea/encodings.xml +.idea/misc.xml +.idea/modules.xml +.idea/scopes/scope_settings.xml +.idea/dictionaries +.idea/vcs.xml +.idea/jsLibraryMappings.xml +.idea/datasources.xml +.idea/dataSources.ids +.idea/sqlDataSources.xml +.idea/dynamic.xml +.idea/uiDesigner.xml +.idea/assetWizardSettings.xml +.idea/gradle.xml +.idea/jarRepositories.xml +.idea/navEditor.xml + +# OS-specific files +.DS_Store +.DS_Store? +._* +.Spotlight-V100 +.Trashes +ehthumbs.db +Thumbs.db + +# Legacy Eclipse project files +.classpath +.project +.cproject +.settings/ + +# Mobile Tools for Java (J2ME) +.mtj.tmp/ + +# Package Files # +*.war +*.ear + +# virtual machine crash logs (Reference: http://www.java.com/en/download/help/error_hotspot.xml) +hs_err_pid* + +## Plugin-specific files: + +# mpeltonen/sbt-idea plugin +.idea_modules/ + +# JIRA plugin +atlassian-ide-plugin.xml + +# Mongo Explorer plugin +.idea/mongoSettings.xml + +# Crashlytics plugin (for Android Studio and IntelliJ) +com_crashlytics_export_strings.xml +crashlytics.properties +crashlytics-build.properties +fabric.properties + +### AndroidStudio Patch ### + +!/gradle/wrapper/gradle-wrapper.jar + +# End of https://www.toptal.com/developers/gitignore/api/androidstudio + + +/app/app-release.apk +Automation_settings.xml diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/app/.gitignore b/app/.gitignore new file mode 100644 index 0000000..74284c4 --- /dev/null +++ b/app/.gitignore @@ -0,0 +1,150 @@ + +# Created by https://www.toptal.com/developers/gitignore/api/androidstudio +# Edit at https://www.toptal.com/developers/gitignore?templates=androidstudio + +### AndroidStudio ### +# Covers files to be ignored for android development using Android Studio. + +# Built application files +*.apk +*.ap_ +*.aab + +# Files for the ART/Dalvik VM +*.dex + +# Java class files +*.class + +# Generated files +bin/ +gen/ +out/ + +# Gradle files +.gradle +.gradle/ +build/ + +# Signing files +.signing/ + +# Local configuration file (sdk path, etc) +local.properties + +# Proguard folder generated by Eclipse +proguard/ + +# Log Files +*.log + +# Android Studio +/*/build/ +/*/local.properties +/*/out +/*/*/build +/*/*/production +captures/ +.navigation/ +*.ipr +*~ +*.swp + +# Keystore files +*.jks +*.keystore + +# Google Services (e.g. APIs or Firebase) +# google-services.json + +# Android Patch +gen-external-apklibs + +# External native build folder generated in Android Studio 2.2 and later +.externalNativeBuild + +# NDK +obj/ + +# IntelliJ IDEA +*.iml +*.iws +/out/ + +# User-specific configurations +.idea/caches/ +.idea/libraries/ +.idea/shelf/ +.idea/workspace.xml +.idea/tasks.xml +.idea/.name +.idea/compiler.xml +.idea/copyright/profiles_settings.xml +.idea/encodings.xml +.idea/misc.xml +.idea/modules.xml +.idea/scopes/scope_settings.xml +.idea/dictionaries +.idea/vcs.xml +.idea/jsLibraryMappings.xml +.idea/datasources.xml +.idea/dataSources.ids +.idea/sqlDataSources.xml +.idea/dynamic.xml +.idea/uiDesigner.xml +.idea/assetWizardSettings.xml +.idea/gradle.xml +.idea/jarRepositories.xml +.idea/navEditor.xml + +# OS-specific files +.DS_Store +.DS_Store? +._* +.Spotlight-V100 +.Trashes +ehthumbs.db +Thumbs.db + +# Legacy Eclipse project files +.classpath +.project +.cproject +.settings/ + +# Mobile Tools for Java (J2ME) +.mtj.tmp/ + +# Package Files # +*.war +*.ear + +# virtual machine crash logs (Reference: http://www.java.com/en/download/help/error_hotspot.xml) +hs_err_pid* + +## Plugin-specific files: + +# mpeltonen/sbt-idea plugin +.idea_modules/ + +# JIRA plugin +atlassian-ide-plugin.xml + +# Mongo Explorer plugin +.idea/mongoSettings.xml + +# Crashlytics plugin (for Android Studio and IntelliJ) +com_crashlytics_export_strings.xml +crashlytics.properties +crashlytics-build.properties +fabric.properties + +### AndroidStudio Patch ### + +!/gradle/wrapper/gradle-wrapper.jar + +# End of https://www.toptal.com/developers/gitignore/api/androidstudio + + +/app/app-release.apk +Automation_settings.xml diff --git a/app/build.gradle b/app/build.gradle new file mode 100644 index 0000000..8ef949d --- /dev/null +++ b/app/build.gradle @@ -0,0 +1,79 @@ +plugins { + id 'com.android.application' +} + +android { + compileSdkVersion 29 + + defaultConfig { + applicationId "com.jens.automation2" + minSdkVersion 14 + compileSdkVersion 29 + buildToolsVersion '29.0.2' + useLibrary 'org.apache.http.legacy' + versionCode 96 + versionName "1.6.21" + + testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" + } + + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' + } + } + compileOptions { + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 + } + + lintOptions { + checkReleaseBuilds false + abortOnError false + } + + flavorDimensions "version" + + productFlavors + { + googlePlayFlavor + { + dimension "version" + applicationIdSuffix ".googlePlay" + versionNameSuffix "-googlePlay" + targetSdkVersion 29 + } + + fdroidFlavor + { + dimension "version" + applicationIdSuffix ".fdroid" + versionNameSuffix "-fdroid" + targetSdkVersion 28 + } + + apkFlavor + { + dimension "version" + applicationIdSuffix ".apk" + versionNameSuffix "-apk" + targetSdkVersion 28 + } + } +} + +dependencies { + googlePlayFlavorImplementation 'com.google.firebase:firebase-appindexing:16.0.1' + googlePlayFlavorImplementation 'com.google.android.gms:play-services-location:15.0.1' + + apkFlavorImplementation 'com.google.firebase:firebase-appindexing:16.0.1' + apkFlavorImplementation 'com.google.android.gms:play-services-location:15.0.1' + + implementation 'androidx.appcompat:appcompat:1.2.0' + + implementation 'com.google.android.material:material:1.1.0' + testImplementation 'junit:junit:4.+' + androidTestImplementation 'androidx.test.ext:junit:1.1.1' + androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0' +} \ No newline at end of file diff --git a/app/proguard-rules.pro b/app/proguard-rules.pro new file mode 100644 index 0000000..481bb43 --- /dev/null +++ b/app/proguard-rules.pro @@ -0,0 +1,21 @@ +# Add project specific ProGuard rules here. +# You can control the set of applied configuration files using the +# proguardFiles setting in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Uncomment this to preserve the line number information for +# debugging stack traces. +#-keepattributes SourceFile,LineNumberTable + +# If you keep the line number information, uncomment this to +# hide the original source file name. +#-renamesourcefileattribute SourceFile \ No newline at end of file diff --git a/app/src/androidTest/java/com/jens/automation2/ExampleInstrumentedTest.java b/app/src/androidTest/java/com/jens/automation2/ExampleInstrumentedTest.java new file mode 100644 index 0000000..e7403b4 --- /dev/null +++ b/app/src/androidTest/java/com/jens/automation2/ExampleInstrumentedTest.java @@ -0,0 +1,28 @@ +package com.jens.automation2; + +import android.content.Context; + +import androidx.test.platform.app.InstrumentationRegistry; +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import static org.junit.Assert.*; + +/** + * Instrumented test, which will execute on an Android device. + * + * @see Testing documentation + */ +@RunWith(AndroidJUnit4.class) +public class ExampleInstrumentedTest +{ + @Test + public void useAppContext() + { + // Context of the app under test. + Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext(); + assertEquals("com.jens.automation2", appContext.getPackageName()); + } +} \ No newline at end of file diff --git a/app/src/apkFlavor/AndroidManifest.xml b/app/src/apkFlavor/AndroidManifest.xml new file mode 100644 index 0000000..398fd94 --- /dev/null +++ b/app/src/apkFlavor/AndroidManifest.xml @@ -0,0 +1,203 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/fdroidFlavor/AndroidManifest.xml b/app/src/fdroidFlavor/AndroidManifest.xml new file mode 100644 index 0000000..b6f9730 --- /dev/null +++ b/app/src/fdroidFlavor/AndroidManifest.xml @@ -0,0 +1,187 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/google-services.json b/app/src/google-services.json new file mode 100644 index 0000000..35b249a --- /dev/null +++ b/app/src/google-services.json @@ -0,0 +1,48 @@ +{ + "project_info": { + "project_number": "977361397436", + "project_id": "automation-9bed6" + }, + "client": [ + { + "client_info": { + "mobilesdk_app_id": "1:977361397436:android:ee5ad5243b40934a", + "android_client_info": { + "package_name": "com.jens.automation2" + } + }, + "oauth_client": [ + { + "client_id": "977361397436-86ebgevdi3ttfhcki5l1ldnquocos854.apps.googleusercontent.com", + "client_type": 1, + "android_info": { + "package_name": "com.jens.automation2", + "certificate_hash": "86ec434e30ed99ec9ee1f4e5c33166558a8442a9" + } + }, + { + "client_id": "977361397436-1n1769oadmm31pckln04pjdkela9p3e4.apps.googleusercontent.com", + "client_type": 3 + } + ], + "api_key": [ + { + "current_key": "AIzaSyCeDEkuDmAr7b03auJKDrL1YAB-KlY7088" + } + ], + "services": { + "analytics_service": { + "status": 1 + }, + "appinvite_service": { + "status": 1, + "other_platform_oauth_client": [] + }, + "ads_service": { + "status": 1 + } + } + } + ], + "configuration_version": "1" +} \ No newline at end of file diff --git a/app/src/googlePlayFlavor/AndroidManifest.xml b/app/src/googlePlayFlavor/AndroidManifest.xml new file mode 100644 index 0000000..3198100 --- /dev/null +++ b/app/src/googlePlayFlavor/AndroidManifest.xml @@ -0,0 +1,203 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml new file mode 100644 index 0000000..a3e1fb2 --- /dev/null +++ b/app/src/main/AndroidManifest.xml @@ -0,0 +1,192 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/java/com/jens/automation2/AESCrypt.java b/app/src/main/java/com/jens/automation2/AESCrypt.java new file mode 100644 index 0000000..8223a4b --- /dev/null +++ b/app/src/main/java/com/jens/automation2/AESCrypt.java @@ -0,0 +1,200 @@ +package com.jens.automation2; + +import android.util.Base64; +import android.util.Log; + +import java.io.UnsupportedEncodingException; +import java.security.GeneralSecurityException; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; + +import javax.crypto.Cipher; +import javax.crypto.spec.IvParameterSpec; +import javax.crypto.spec.SecretKeySpec; + +/** + * Encrypt and decrypt messages using AES 256 bit encryption that are compatible with AESCrypt-ObjC and AESCrypt Ruby. + *

+ * Created by scottab on 04/10/2014. + */ +public final class AESCrypt +{ + private static final String TAG = "AESCrypt"; + + //AESCrypt-ObjC uses CBC and PKCS7Padding + private static final String AES_MODE = "AES/CBC/PKCS7Padding"; +// private static final String AES_MODE = "AES/ECB/NoPadding"; + private static final String CHARSET = "UTF-8"; + + //AESCrypt-ObjC uses SHA-256 (and so a 256-bit key) + private static final String HASH_ALGORITHM = "SHA-256"; + + //AESCrypt-ObjC uses blank IV (not the best security, but the aim here is compatibility) + private static final byte[] ivBytes = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + + //togglable log option (please turn off in live!) + public static boolean DEBUG_LOG_ENABLED = false; + + + /** + * Generates SHA256 hash of the password which is used as key + * + * @param password used to generated key + * @return SHA256 of the password + */ + private static SecretKeySpec generateKey(final String password) throws NoSuchAlgorithmException, UnsupportedEncodingException { + final MessageDigest digest = MessageDigest.getInstance(HASH_ALGORITHM); + byte[] bytes = password.getBytes("UTF-8"); + digest.update(bytes, 0, bytes.length); + byte[] key = digest.digest(); + + log("SHA-256 key ", key); + + SecretKeySpec secretKeySpec = new SecretKeySpec(key, "AES"); + return secretKeySpec; + } + + + /** + * Encrypt and encode message using 256-bit AES with key generated from password. + * + * + * @param password used to generated key + * @param message the thing you want to encrypt assumed String UTF-8 + * @return Base64 encoded CipherText + * @throws GeneralSecurityException if problems occur during encryption + */ + public static String encrypt(final String password, String message) + throws GeneralSecurityException { + + try { + final SecretKeySpec key = generateKey(password); + + log("message", message); + + byte[] cipherText = encrypt(key, ivBytes, message.getBytes(CHARSET)); + + //NO_WRAP is important as was getting \n at the end + String encoded = Base64.encodeToString(cipherText, Base64.NO_WRAP); + log("Base64.NO_WRAP", encoded); + return encoded; + } catch (UnsupportedEncodingException e) { + if (DEBUG_LOG_ENABLED) + Log.e(TAG, "UnsupportedEncodingException ", e); + throw new GeneralSecurityException(e); + } + } + + + /** + * More flexible AES encrypt that doesn't encode + * @param key AES key typically 128, 192 or 256 bit + * @param iv Initiation Vector + * @param message in bytes (assumed it's already been decoded) + * @return Encrypted cipher text (not encoded) + * @throws GeneralSecurityException if something goes wrong during encryption + */ + public static byte[] encrypt(final SecretKeySpec key, final byte[] iv, final byte[] message) + throws GeneralSecurityException { + final Cipher cipher = Cipher.getInstance(AES_MODE); + IvParameterSpec ivSpec = new IvParameterSpec(iv); + cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec); + byte[] cipherText = cipher.doFinal(message); + + log("cipherText", cipherText); + + return cipherText; + } + + + /** + * Decrypt and decode ciphertext using 256-bit AES with key generated from password + * + * @param password used to generated key + * @param base64EncodedCipherText the encrpyted message encoded with base64 + * @return message in Plain text (String UTF-8) + * @throws GeneralSecurityException if there's an issue decrypting + */ + public static String decrypt(final String password, String base64EncodedCipherText) + throws GeneralSecurityException { + + try { + final SecretKeySpec key = generateKey(password); + + log("base64EncodedCipherText", base64EncodedCipherText); + byte[] decodedCipherText = Base64.decode(base64EncodedCipherText, Base64.NO_WRAP); + log("decodedCipherText", decodedCipherText); + + byte[] decryptedBytes = decrypt(key, ivBytes, decodedCipherText); + + log("decryptedBytes", decryptedBytes); + String message = new String(decryptedBytes, CHARSET); + log("message", message); + + + return message; + } catch (UnsupportedEncodingException e) { + if (DEBUG_LOG_ENABLED) + Log.e(TAG, "UnsupportedEncodingException ", e); + + throw new GeneralSecurityException(e); + } + } + + + /** + * More flexible AES decrypt that doesn't encode + * + * @param key AES key typically 128, 192 or 256 bit + * @param iv Initiation Vector + * @param decodedCipherText in bytes (assumed it's already been decoded) + * @return Decrypted message cipher text (not encoded) + * @throws GeneralSecurityException if something goes wrong during encryption + */ + public static byte[] decrypt(final SecretKeySpec key, final byte[] iv, final byte[] decodedCipherText) + throws GeneralSecurityException { + final Cipher cipher = Cipher.getInstance(AES_MODE); + IvParameterSpec ivSpec = new IvParameterSpec(iv); + cipher.init(Cipher.DECRYPT_MODE, key, ivSpec); + byte[] decryptedBytes = cipher.doFinal(decodedCipherText); + + log("decryptedBytes", decryptedBytes); + + return decryptedBytes; + } + + + + + private static void log(String what, byte[] bytes) { + if (DEBUG_LOG_ENABLED) + Log.d(TAG, what + "[" + bytes.length + "] [" + bytesToHex(bytes) + "]"); + } + + private static void log(String what, String value) { + if (DEBUG_LOG_ENABLED) + Log.d(TAG, what + "[" + value.length() + "] [" + value + "]"); + } + + + /** + * Converts byte array to hexidecimal useful for logging and fault finding + * @param bytes + * @return + */ + private static String bytesToHex(byte[] bytes) { + final char[] hexArray = {'0', '1', '2', '3', '4', '5', '6', '7', '8', + '9', 'A', 'B', 'C', 'D', 'E', 'F'}; + char[] hexChars = new char[bytes.length * 2]; + int v; + for (int j = 0; j < bytes.length; j++) { + v = bytes[j] & 0xFF; + hexChars[j * 2] = hexArray[v >>> 4]; + hexChars[j * 2 + 1] = hexArray[v & 0x0F]; + } + return new String(hexChars); + } + + private AESCrypt() { + } +} \ No newline at end of file diff --git a/app/src/main/java/com/jens/automation2/Action.java b/app/src/main/java/com/jens/automation2/Action.java new file mode 100644 index 0000000..576cfe3 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/Action.java @@ -0,0 +1,537 @@ +package com.jens.automation2; + +import android.content.Context; +import android.os.AsyncTask; +import android.util.Log; + +import org.apache.http.client.methods.HttpGet; + +import java.util.ArrayList; +import java.util.Locale; + + +public class Action +{ + public enum Action_Enum { + setWifi, + setBluetooth, + setUsbTethering, + setWifiTethering, + setDisplayRotation, + turnWifiOn,turnWifiOff, + turnBluetoothOn,turnBluetoothOff, + triggerUrl, + changeSoundProfile, + turnUsbTetheringOn,turnUsbTetheringOff, + turnWifiTetheringOn,turnWifiTetheringOff, + enableScreenRotation, disableScreenRotation, + startOtherActivity, + waitBeforeNextAction, + wakeupDevice, + setAirplaneMode, + setDataConnection, + speakText, + playMusic, + setScreenBrightness, + sendTextMessage; + + public String getFullName(Context context) + { + switch(this) + { + case setWifi: + return context.getResources().getString(R.string.actionSetWifi); + case setBluetooth: + return context.getResources().getString(R.string.actionSetBluetooth); + case setWifiTethering: + return context.getResources().getString(R.string.actionSetWifiTethering); + case setUsbTethering: + return context.getResources().getString(R.string.actionSetUsbTethering); + case setDisplayRotation: + return context.getResources().getString(R.string.actionSetDisplayRotation); + case turnWifiOn: + return context.getResources().getString(R.string.actionTurnWifiOn); + case turnWifiOff: + return context.getResources().getString(R.string.actionTurnWifiOff); + case turnBluetoothOn: + return context.getResources().getString(R.string.actionTurnBluetoothOn); + case turnBluetoothOff: + return context.getResources().getString(R.string.actionTurnBluetoothOff); + case triggerUrl: + return context.getResources().getString(R.string.actionTriggerUrl); + case changeSoundProfile: + return context.getResources().getString(R.string.actionChangeSoundProfile); + case turnUsbTetheringOn: + return context.getResources().getString(R.string.actionTurnUsbTetheringOn); + case turnUsbTetheringOff: + return context.getResources().getString(R.string.actionTurnUsbTetheringOff); + case turnWifiTetheringOn: + return context.getResources().getString(R.string.actionTurnWifiTetheringOn); + case turnWifiTetheringOff: + return context.getResources().getString(R.string.actionTurnWifiTetheringOff); + case enableScreenRotation: + return context.getResources().getString(R.string.actionEnableScreenRotation); + case disableScreenRotation: + return context.getResources().getString(R.string.actionDisableScreenRotation); + case startOtherActivity: + return context.getResources().getString(R.string.startOtherActivity); + case waitBeforeNextAction: + return context.getResources().getString(R.string.waitBeforeNextAction); + case wakeupDevice: + return context.getResources().getString(R.string.wakeupDevice); + case setAirplaneMode: + return context.getResources().getString(R.string.airplaneMode); + case setDataConnection: + return context.getResources().getString(R.string.actionDataConnection); + case speakText: + return context.getResources().getString(R.string.actionSpeakText); + case playMusic: + return context.getResources().getString(R.string.actionPlayMusic); + case sendTextMessage: + return context.getResources().getString(R.string.sendTextMessage); + case setScreenBrightness: + return context.getResources().getString(R.string.setScreenBrightness); + default: + return "Unknown"; + } + } + }; + + private Action_Enum action; + private boolean parameter1 = false; + private String parameter2 = ""; + + public Action_Enum getAction() + { + return action; + } + public void setAction(Action_Enum action) + { + this.action = action; + } + + public boolean getParameter1() + { + return parameter1; + } + public void setParameter1(boolean parameter1) + { + this.parameter1 = parameter1; + } + public String getParameter2() + { + return parameter2; + } + public void setParameter2(String parameter) + { + this.parameter2 = parameter; + } + public String toStringShort() + { + String returnString = action.toString(); + + return returnString; + } + @Override + public String toString() + { + StringBuilder returnString = new StringBuilder(); + + if(this.getAction().equals(Action_Enum.setWifi)) + { + if(this.getParameter1()) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.actionTurnWifiOn)); + else + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.actionTurnWifiOff)); + } + else if(this.getAction().equals(Action_Enum.setBluetooth)) + { + if(this.getParameter1()) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.actionTurnBluetoothOn)); + else + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.actionTurnBluetoothOff)); + } + else if(this.getAction().equals(Action_Enum.setUsbTethering)) + { + if(this.getParameter1()) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.actionTurnUsbTetheringOn)); + else + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.actionTurnUsbTetheringOff)); + } + else if(this.getAction().equals(Action_Enum.setWifiTethering)) + { + if(this.getParameter1()) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.actionTurnWifiTetheringOn)); + else + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.actionTurnWifiTetheringOff)); + } + else if(this.getAction().equals(Action_Enum.setDisplayRotation)) + { + if(this.getParameter1()) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.actionEnableScreenRotation)); + else + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.actionDisableScreenRotation)); + } + else if(this.getAction().equals(Action_Enum.setAirplaneMode)) + { + if(this.getParameter1()) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.actionTurnAirplaneModeOn)); + else + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.actionTurnAirplaneModeOff)); + } + else if(this.getAction().equals(Action_Enum.setDataConnection)) + { + if(this.getParameter1()) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.actionSetDataConnectionOn)); + else + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.actionSetDataConnectionOff)); + } + else if(this.getAction().equals(Action_Enum.startOtherActivity)) + { + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.startOtherActivity)); + } + else if(this.getAction().equals(Action_Enum.triggerUrl)) + { + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.actionTriggerUrl)); + } + else if(this.getAction().equals(Action_Enum.speakText)) + { + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.actionSpeakText)); + } + else if(this.getAction().equals(Action_Enum.playMusic)) + { + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.actionPlayMusic)); + } + else if(this.getAction().equals(Action_Enum.sendTextMessage)) + { + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.sendTextMessage)); + } + else if(this.getAction().equals(Action_Enum.wakeupDevice)) + { + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.wakeupDevice)); + } + else + returnString.append(action.toString()); + + if(this.getAction().equals(Action_Enum.triggerUrl)) + { + String[] components = parameter2.split(";"); + if(components.length >= 3) + { + returnString.append(": " + components[2]); + + if(parameter1) + returnString.append(" using authentication."); + } + else + returnString.append(": " + components[0]); + } + else if(this.getAction().equals(Action_Enum.sendTextMessage)) + { + String[] components = parameter2.split(Actions.smsSeparator); + if(components.length >= 2) + { + returnString.append(" to number " + components[0]); + + returnString.append(". Message: " + components[1]); + } + } + else if(this.getAction().equals(Action_Enum.setScreenBrightness)) + { + returnString.append(" to "); + + if(parameter1) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.brightnessAuto)); + else + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.brightnessManual)); + + returnString.append(" / " + Integer.parseInt(parameter2) + "%"); + } + else + if (parameter2 != null && parameter2.length() > 0) + returnString.append(": " + parameter2); + + return returnString.toString(); + } + + public static CharSequence[] getActionTypesAsArray() + { + ArrayList actionTypesList = new ArrayList(); + + for(Action_Enum action : Action_Enum.values()) + { + if( // exclusion for deprecated types + !action.toString().equals("turnWifiOn") + && + !action.toString().equals("turnWifiOff") + && + !action.toString().equals("turnBluetoothOn") + && + !action.toString().equals("turnBluetoothOff") + && + !action.toString().equals("turnUsbTetheringOn") + && + !action.toString().equals("turnUsbTetheringOff") + && + !action.toString().equals("turnWifiTetheringOn") + && + !action.toString().equals("turnWifiTetheringOff") + && + !action.toString().equals("enableScreenRotation") + && + !action.toString().equals("disableScreenRotation") + ) // exclusion for deprecated types + actionTypesList.add(action.toString()); + } + + return (String[])actionTypesList.toArray(new String[actionTypesList.size()]); + } + public static CharSequence[] getActionTypesFullNameStringAsArray(Context context) + { + ArrayList actionTypesList = new ArrayList(); + + for(Action_Enum action : Action_Enum.values()) + { + if( // exclusion for deprecated types + !action.toString().equals("turnWifiOn") + && + !action.toString().equals("turnWifiOff") + && + !action.toString().equals("turnBluetoothOn") + && + !action.toString().equals("turnBluetoothOff") + && + !action.toString().equals("turnUsbTetheringOn") + && + !action.toString().equals("turnUsbTetheringOff") + && + !action.toString().equals("turnWifiTetheringOn") + && + !action.toString().equals("turnWifiTetheringOff") + && + !action.toString().equals("enableScreenRotation") + && + !action.toString().equals("disableScreenRotation") + ) // exclusion for deprecated types + actionTypesList.add(action.getFullName(context)); + } + + return (String[])actionTypesList.toArray(new String[actionTypesList.size()]); + } + + public void run(Context context, boolean toggleActionIfPossible) + { + switch(this.getAction()) + { + case changeSoundProfile: + /* + * Old version. Those checks should not be necessary anymore. Also they didn't work + * because profiles were created with names like silent, vibrate and normal. + */ +// if(this.getParameter2().equals("silent")) +// Actions.setSound(context, AudioManager.RINGER_MODE_SILENT); +// else if(this.getParameter2().equals("vibrate")) +// Actions.setSound(context, AudioManager.RINGER_MODE_VIBRATE); +// else if(this.getParameter2().equals("normal")) +// Actions.setSound(context, AudioManager.RINGER_MODE_NORMAL); +// else +// { + Profile p = Profile.getByName(this.getParameter2()); + if(p != null) + p.activate(context); +// } + break; + case triggerUrl: + triggerUrl(context); + break; + case setBluetooth: + Actions.setBluetooth(context, getParameter1(), toggleActionIfPossible); + break; + case setUsbTethering: + Actions.setUsbTethering(context, getParameter1(), toggleActionIfPossible); + break; + case setWifi: + Actions.setWifi(context, getParameter1(), toggleActionIfPossible); + break; + case setWifiTethering: + Actions.setWifiTethering(context, getParameter1(), toggleActionIfPossible); + break; + case setDisplayRotation: + Actions.setDisplayRotation(context, getParameter1(), toggleActionIfPossible); + break; + case startOtherActivity: + Actions.startOtherActivity(getParameter2()); + break; + case waitBeforeNextAction: + Actions.waitBeforeNextAction(Long.parseLong(this.getParameter2())); + break; + case wakeupDevice: + Actions.wakeupDevice(Long.parseLong(this.getParameter2())); + // wakeupDevice() will create a seperate thread. That'll take some time, we wait 100ms. + try + { + Thread.sleep(100); + } + catch (InterruptedException e) + { + e.printStackTrace(); + } + break; + case setAirplaneMode: + Actions.setAirplaneMode(this.getParameter1(), toggleActionIfPossible); + break; + case setDataConnection: + Actions.MobileDataStuff.setDataConnection(this.getParameter1(), toggleActionIfPossible); + break; + case speakText: + Actions.speakText(this.getParameter2()); + break; + case playMusic: + Actions.playMusic(this.getParameter1(), toggleActionIfPossible); + break; + case sendTextMessage: + Actions.sendTextMessage(context, this.getParameter2().split(Actions.smsSeparator)); + break; + case setScreenBrightness: + Actions.setScreenBrightness(getParameter1(), Integer.parseInt(getParameter2())); + break; + default: + Miscellaneous.logEvent("w", "Action", context.getResources().getString(R.string.unknownActionSpecified), 3); + break; + } + } + + private void triggerUrl(Context context) + { + String username = null; + String password = null; + String url; + + String[] components = getParameter2().split(";"); + + if(components.length >= 3) + { + username = components[0]; + password = components[1]; + url = components[2]; + } + else + url = components[0]; + + try + { + url = Miscellaneous.replaceVariablesInText(url, context); + + Actions myAction = new Actions(); + + Miscellaneous.logEvent("i", "HTTP", "Attempting download of " + url, 4); //getResources().getString("attemptingDownloadOf"); + + if(this.getParameter1()) // use authentication + new DownloadTask().execute(url, username, password); + else + new DownloadTask().execute(url, null, null); + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "triggerUrl", context.getResources().getString(R.string.errorTriggeringUrl) + ": " + e.getMessage() + ", detailed: " + Log.getStackTraceString(e), 2); + } + } + + public class DownloadTask extends AsyncTask + { + @Override + public String doInBackground(String... parameters) + { + Thread.setDefaultUncaughtExceptionHandler(Miscellaneous.uncaughtExceptionHandler); + + int attempts=1; + String urlString=parameters[0]; + + String urlUsername = null; + String urlPassword = null; + if(parameters.length >= 3) + { + urlUsername=parameters[1]; + urlPassword=parameters[2]; + } + + String response = "httpError"; + HttpGet post; + + if(Settings.httpAttempts < 1) + Miscellaneous.logEvent("w", "HTTP Request", Miscellaneous.getAnyContext().getResources().getString(R.string.cantDownloadTooFewRequestsInSettings), 3); + + while(attempts <= Settings.httpAttempts && response.equals("httpError")) + { + Miscellaneous.logEvent("i", "HTTP Request", "Attempt " + String.valueOf(attempts++) + " of " + String.valueOf(Settings.httpAttempts), 3); + +// try +// { + // Either thorough checking or no encryption + if(!Settings.httpAcceptAllCertificates | !urlString.toLowerCase(Locale.getDefault()).contains("https")) +// { +// URL url = new URL(urlString); +// URLConnection urlConnection = url.openConnection(); +// urlConnection.setReadTimeout(Settings.httpAttemptsTimeout * 1000); +// InputStream in = urlConnection.getInputStream(); +// response = Miscellaneous.convertStreamToString(in); + + response = Miscellaneous.downloadURL(urlString, urlUsername, urlPassword); +// } + else +// { + response = Miscellaneous.downloadURLwithoutCertificateChecking(urlString, urlUsername, urlPassword); +// post = new HttpGet(new URI(urlString)); +// final HttpParams httpParams = new BasicHttpParams(); +// HttpConnectionParams.setConnectionTimeout(httpParams, Settings.httpAttemptsTimeout * 1000); +// HttpClient client = new DefaultHttpClient(httpParams); +// +// client = sslClient(client); +// +// // Execute HTTP Post Request +// HttpResponse result = client.execute(post); +// response = EntityUtils.toString(result.getEntity()); +// } +// } +// catch (URISyntaxException e) +// { +// Miscellaneous.logEvent("w", "HTTP RESULT", Log.getStackTraceString(e), 3); +// } +// catch (ClientProtocolException e) +// { +// Miscellaneous.logEvent("w", "HTTP RESULT", Log.getStackTraceString(e), 3); +// } +// catch (IOException e) +// { +// Miscellaneous.logEvent("w", "HTTP RESULT", Log.getStackTraceString(e), 3); +// e.printStackTrace(); +// } +// finally +// { + try + { + Thread.sleep(Settings.httpAttemptGap * 1000); + } + catch (InterruptedException e1) + { + Miscellaneous.logEvent("w", "HTTP RESULT", "Failed to pause between HTTP requests.", 5); + } +// } + } + +// Miscellaneous.logEvent("i", "HTTPS RESULT", response, 3); + + return response; + } + + @Override + public void onPostExecute(String result) + { + //Do something with result + //Toast.makeText(context, text, duration) result; + Miscellaneous.logEvent("i", "HTTP RESULT", result, 3); + Actions myAction=new Actions(); + myAction.useDownloadedWebpage(result); + } + } +} \ No newline at end of file diff --git a/app/src/main/java/com/jens/automation2/Actions.java b/app/src/main/java/com/jens/automation2/Actions.java new file mode 100644 index 0000000..fa6cf3a --- /dev/null +++ b/app/src/main/java/com/jens/automation2/Actions.java @@ -0,0 +1,1192 @@ +package com.jens.automation2; + +import android.annotation.SuppressLint; +import android.annotation.TargetApi; +import android.app.PendingIntent; +import android.bluetooth.BluetoothAdapter; +import android.content.ActivityNotFoundException; +import android.content.Context; +import android.content.Intent; +import android.media.AudioManager; +import android.net.ConnectivityManager; +import android.net.wifi.WifiManager; +import android.os.Build; +import android.os.PowerManager; +import android.os.PowerManager.WakeLock; +import android.provider.MediaStore; +import android.telephony.SmsManager; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; +import android.util.Log; +import android.view.WindowManager; +import android.widget.Toast; + +import com.jens.automation2.location.WifiBroadcastReceiver; +import com.jens.automation2.receivers.ConnectivityReceiver; + +import org.apache.http.client.HttpClient; +import org.apache.http.conn.ClientConnectionManager; +import org.apache.http.conn.scheme.Scheme; +import org.apache.http.conn.scheme.SchemeRegistry; +import org.apache.http.conn.ssl.SSLSocketFactory; +import org.apache.http.conn.util.InetAddressUtils; +import org.apache.http.impl.client.DefaultHttpClient; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.net.InetAddress; +import java.net.NetworkInterface; +import java.security.KeyStore; +import java.util.Collections; +import java.util.List; + +import javax.net.ssl.SSLContext; + +import eu.chainfire.libsuperuser.Shell; + +public class Actions +{ + public static AutomationService autoMationServerRef; + public static Context context; + private static Intent playMusicIntent; + private static boolean suAvailable = false; + private static String suVersion = null; + private static String suVersionInternal = null; + private static List suResult = null; + final static String smsSeparator = "&sms&"; + + public static Boolean setWifi(Context context, Boolean desiredState, boolean toggleActionIfPossible) + { + Miscellaneous.logEvent("i", "Wifi", "Changing Wifi to " + String.valueOf(desiredState), 4); + + if(desiredState && Settings.useWifiForPositioning) + WifiBroadcastReceiver.startWifiReceiver(autoMationServerRef.getLocationProvider()); + + WifiManager myWifi = (WifiManager)context.getSystemService(Context.WIFI_SERVICE); + + // toggle + if(toggleActionIfPossible) + { + Toast.makeText(context, context.getResources().getString(R.string.toggling) + " " + context.getResources().getString(R.string.wifi), Toast.LENGTH_LONG).show(); + desiredState = !myWifi.isWifiEnabled(); + } + + // Only perform action if necessary + if((!myWifi.isWifiEnabled() && desiredState) | (myWifi.isWifiEnabled() && !desiredState)) + { + String wifiString = ""; + + if(desiredState) + { + wifiString = context.getResources().getString(R.string.activating) + " " + context.getResources().getString(R.string.wifi); + } + else + { + wifiString = context.getResources().getString(R.string.deactivating) + " " + context.getResources().getString(R.string.wifi); + } + + Toast.makeText(context, wifiString, Toast.LENGTH_LONG).show(); + + boolean returnValue = myWifi.setWifiEnabled(desiredState); + if(!returnValue) + Miscellaneous.logEvent("i", "Wifi", "Error changing Wifi to " + String.valueOf(desiredState), 2); + else + Miscellaneous.logEvent("i", "Wifi", "Wifi changed to " + String.valueOf(desiredState), 2); + + return returnValue; + } + + return true; + } + + public static void setDisplayRotation(Context myContext, Boolean desiredState, boolean toggleActionIfPossible) + { + Miscellaneous.logEvent("i", "ScreenRotation", "Changing ScreenRotation to " + String.valueOf(desiredState), 4); + try + { + if(toggleActionIfPossible) + { + Miscellaneous.logEvent("i", "setScreenRotation", myContext.getResources().getString(R.string.toggling), 2); + boolean currentStatus = android.provider.Settings.System.getInt(myContext.getContentResolver(),android.provider.Settings.System.ACCELEROMETER_ROTATION, 0) == 0; + if(currentStatus) + desiredState = !currentStatus; + } + + if(desiredState) + { + if(android.provider.Settings.System.getInt(myContext.getContentResolver(),android.provider.Settings.System.ACCELEROMETER_ROTATION, 0) == 0) + { + android.provider.Settings.System.putInt(myContext.getContentResolver(),android.provider.Settings.System.ACCELEROMETER_ROTATION, 1); + Miscellaneous.logEvent("i", "setScreenRotation", myContext.getResources().getString(R.string.screenRotationEnabled), 2); + } + else + Miscellaneous.logEvent("i", "setScreenRotation", myContext.getResources().getString(R.string.screenRotationAlreadyEnabled), 2); + } + else + { + if(android.provider.Settings.System.getInt(myContext.getContentResolver(),android.provider.Settings.System.ACCELEROMETER_ROTATION, 0) == 1) + { + android.provider.Settings.System.putInt(myContext.getContentResolver(),android.provider.Settings.System.ACCELEROMETER_ROTATION, 0); + Miscellaneous.logEvent("i", "setScreenRotation", myContext.getResources().getString(R.string.screenRotationDisabled), 2); + } + else + Miscellaneous.logEvent("i", "setScreenRotation", myContext.getResources().getString(R.string.screenRotationAlreadyDisabled), 2); + } + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "setScreenRotation", myContext.getResources().getString(R.string.errorChangingScreenRotation) + ": " + Log.getStackTraceString(e), 2); + } + } + + private static boolean isWifiApEnabled(Context context) + { + WifiManager wifiManager = (WifiManager)context.getSystemService(Context.WIFI_SERVICE); + boolean currentlyEnabled = false; + + Method[] methods = wifiManager.getClass().getDeclaredMethods(); + for(Method method : methods) + { + if(method.getName().equals("isWifiApEnabled")) + { + try + { + Object returnObject = method.invoke(wifiManager); + currentlyEnabled = Boolean.valueOf(returnObject.toString()); + + if(currentlyEnabled) + Miscellaneous.logEvent("i", "isWifiApEnabled", "true", 5); + else + Miscellaneous.logEvent("i", "isWifiApEnabled", "false", 5); + } + catch(Exception e) + { + Miscellaneous.logEvent("i", "isWifiApEnabled", context.getResources().getString(R.string.errorDeterminingWifiApState) + ": " + e.getMessage(), 4); + } + } + } + return currentlyEnabled; + } + public static Boolean setWifiTethering(Context context, Boolean desiredState, boolean toggleActionIfPossible) + { + Miscellaneous.logEvent("i", "WifiTethering", "Changing WifiTethering to " + String.valueOf(desiredState), 4); + + boolean state = Actions.isWifiApEnabled(context); + + if(toggleActionIfPossible) + { + Miscellaneous.logEvent("i", "WifiAp", context.getResources().getString(R.string.toggling), 2); + desiredState = !state; + } + + if(((state && !desiredState) || (!state && desiredState))) + { + WifiManager wifiManager = (WifiManager)context.getSystemService(Context.WIFI_SERVICE); + Method[] methods = wifiManager.getClass().getDeclaredMethods(); + for(Method method : methods) + { +// Miscellaneous.logEvent("i", "WifiAp", "Trying to find appropriate method... " + method.getName()); + if(method.getName().equals("setWifiApEnabled")) + { + try + { + String desiredString = ""; + if(desiredState) + desiredString = "activate"; + else + desiredString = "deactivate"; + + if(!toggleActionIfPossible) + { + Miscellaneous.logEvent("i", "WifiAp", "Trying to " + desiredString + " wifi ap...", 2); + if(!method.isAccessible()) + method.setAccessible(true); + method.invoke(wifiManager, null, desiredState); + } + else + { + Miscellaneous.logEvent("i", "WifiAp", "Trying to " + context.getResources().getString(R.string.toggle) + " wifi ap...", 2); + if(!method.isAccessible()) + method.setAccessible(true); + method.invoke(wifiManager, null, !state); + } + + Miscellaneous.logEvent("i", "WifiAp", "Wifi ap " + desiredString + "d.", 2); + } + catch(Exception e) + { + Miscellaneous.logEvent("i", "WifiAp", context.getResources().getString(R.string.errorActivatingWifiAp) + ". " + e.getMessage(), 2); + } + } + } + } + return true; + } + + public static boolean setUsbTethering(Context context2, Boolean desiredState, boolean toggleActionIfPossible) + { + //TODO:toggle not really implemented, yet + + Miscellaneous.logEvent("i", "UsbTethering", "Changing UsbTethering to " + String.valueOf(desiredState), 4); + + boolean state = false; //Actions.isWifiApEnabled(context); + Object connectivityServiceObject = null; + ConnectivityManager connMgr = null; + + try + { + connectivityServiceObject = context.getSystemService(Context.CONNECTIVITY_SERVICE); + connMgr = (ConnectivityManager)connectivityServiceObject; + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "UsbTethering", context2.getResources().getString(R.string.logErrorGettingConnectionManagerService), 2); + return false; + } + + try + { + if((state && !desiredState) || (!state && desiredState)) + { + try + { + Method method = connectivityServiceObject.getClass().getDeclaredMethod("getTetheredIfaces"); + if(!method.isAccessible()) + method.setAccessible(true); + String[] tetheredInterfaces = (String[]) method.invoke(connectivityServiceObject); + if(tetheredInterfaces.length > 0) + state = true; + } + catch(NoSuchMethodException e) + { + // System doesn't have that method, try another way + + String ipAddr = getIPAddressUsb(true); + if (ipAddr.length() == 0) + state = false; // tethering not enabled + else + state = true; // tethering enabled + } + } + } + catch(Exception e) + { + Miscellaneous.logEvent("w", "UsbTethering", context2.getResources().getString(R.string.logErrorDeterminingCurrentUsbTetheringState), 3); + } + + if(toggleActionIfPossible) + { + Miscellaneous.logEvent("w", "UsbTethering", context2.getResources().getString(R.string.toggling), 3); + desiredState = !state; + } + + + if((state && !desiredState) || (!state && desiredState)) + { + String desiredString = ""; + if(desiredState) + desiredString = "activate"; + else + desiredString = "deactivate"; + + try + { + Method method = null; + + for(Method m : connectivityServiceObject.getClass().getDeclaredMethods()) + { + if(desiredState && m.getName().equals("tether")) + { + method = m; + break; + } + + if(!desiredState && m.getName().equals("untether")) + { + method = m; + break; + } + } + + if(method == null) + throw new NoSuchMethodException(); + + + /* + * For some reason this doesn't work, throws NoSuchMethodExpection even if the method is present. + */ +// if(desiredState) +// method = connectivityServiceObject.getClass().getDeclaredMethod("tether"); +// else +// method = connectivityServiceObject.getClass().getDeclaredMethod("untether"); + + // DETECT INTERFACE NAME + Miscellaneous.logEvent("i", "UsbTethering", context2.getResources().getString(R.string.logDetectingTetherableUsbInterface), 4); + String[] available = null; + Method[] wmMethods = connMgr.getClass().getDeclaredMethods(); + for(Method getMethod: wmMethods) + { + if(getMethod.getName().equals("getTetherableUsbRegexs")) + { + try + { + if(!method.isAccessible()) + method.setAccessible(true); + available = (String[]) getMethod.invoke(connMgr); +// break; + } + catch (Exception e) + { + e.printStackTrace(); + } + } + } + // DETECT INTERFACE NAME + + + if(available.length > 0) + { + for(String interfaceName : available) + { + Miscellaneous.logEvent("i", "UsbTethering", "Detected " + String.valueOf(available.length) + " tetherable usb interfaces.", 5); + Miscellaneous.logEvent("i", "UsbTethering", "Trying to " + desiredString + " UsbTethering on interface " + interfaceName + "...", 5); + if(!method.isAccessible()) + method.setAccessible(true); + Integer returnCode = (Integer)method.invoke(connectivityServiceObject, interfaceName); + if(returnCode == 0) + { + Miscellaneous.logEvent("i", "UsbTethering", "UsbTethering " + desiredString + "d.", 5); + return true; + } + else + { + Miscellaneous.logEvent("w", "UsbTethering", "Failed to " + desiredString + "Usb Tethering. ReturnCode of method " + method.getName() + ": " + String.valueOf(returnCode), 5); + } + } + } + } + catch (NoSuchMethodException e) + { + Miscellaneous.logEvent("w", "UsbTethering", "Error while trying to " + desiredString + " UsbTethering. This kind of error may indicate we are above Android 2.3: " + Log.getStackTraceString(e), 3); + } + catch(Exception e) + { + Miscellaneous.logEvent("w", "UsbTethering", "Error while trying to " + desiredString + " UsbTethering. " + Log.getStackTraceString(e), 3); + } + } + return false; + } + + public static Boolean setBluetooth(Context context, Boolean desiredState, boolean toggleActionIfPossible) + { + Miscellaneous.logEvent("i", "Bluetooth", "Changing bluetooth to " + String.valueOf(desiredState), 4); + + try + { + BluetoothAdapter myBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); + + // toggle + if(toggleActionIfPossible) + { + Miscellaneous.logEvent("e", "SetBluetooth", context.getResources().getString(R.string.toggling), 2); + desiredState = !myBluetoothAdapter.isEnabled(); + } + + // activate + if(!myBluetoothAdapter.isEnabled() && desiredState) + { + Toast.makeText(context, context.getResources().getString(R.string.activating) + " Bluetooth.", Toast.LENGTH_LONG).show(); + myBluetoothAdapter.enable(); + return true; + } + + // deactivate + if(myBluetoothAdapter.isEnabled() && !desiredState) + { + Toast.makeText(context, context.getResources().getString(R.string.deactivating) + " Bluetooth.", Toast.LENGTH_LONG).show(); + myBluetoothAdapter.disable(); + return true; + } + } + catch(NullPointerException e) + { + Miscellaneous.logEvent("e", "SetBluetooth", context.getResources().getString(R.string.failedToTriggerBluetooth), 2); + Toast.makeText(context, context.getResources().getString(R.string.bluetoothFailed), Toast.LENGTH_LONG).show(); + } + + return false; + } + + public static void setSound(Context context, int soundSetting) + { + Miscellaneous.logEvent("i", context.getResources().getString(R.string.soundSettings), "Changing sound to " + String.valueOf(soundSetting), 4); + + AudioManager myAudioManager = (AudioManager)context.getSystemService(Context.AUDIO_SERVICE); + myAudioManager.setRingerMode(soundSetting); + } + + private static String getIPAddressUsb(final boolean useIPv4) + { + try + { + final List interfaces = Collections.list(NetworkInterface.getNetworkInterfaces()); + for (final NetworkInterface intf : interfaces) + { + if (intf.getDisplayName().startsWith("usb")) // ro "rndis0" + { + final List addrs = Collections.list(intf.getInetAddresses()); + for (final InetAddress addr : addrs) + { + final String sAddr = addr.getHostAddress().toUpperCase(); + final boolean isIPv4 = InetAddressUtils.isIPv4Address(sAddr); + if (useIPv4) + { + if (isIPv4) + { + return sAddr; + } + } + else + { + if (!isIPv4) + { + final int delim = sAddr.indexOf('%'); + return delim < 0 ? sAddr : sAddr.substring(0, delim); + } + } + } + } + } + } + catch (final Exception ex) + { + // for now eat exceptions + } + return ""; + } + + public void useDownloadedWebpage(String result) + { +// Toast.makeText(context, "Result: " + result, Toast.LENGTH_LONG).show(); + } + + public static HttpClient getInsecureSslClient(HttpClient client) + { + try + { + SSLContext ctx = SSLContext.getInstance("TLS"); + SSLSocketFactory ssf = null; +// MySSLSocketFactoryInsecure ssfI = null; + +// if(!Settings.httpAcceptAllCertificates) +// { +// ssf = new MySSLSocketFactory(ctx); +// ssf.setHostnameVerifier(SSLSocketFactory.STRICT_HOSTNAME_VERIFIER); +// +// char[] keystorePass="insecure".toCharArray(); //passphrase for keystore +// KeyStore keyStore=KeyStore.getInstance("BKS"); +// +//// String tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm(); +// TrustManagerFactory tmf = TrustManagerFactory.getInstance("X509"); +// tmf.init(keyStore); +// +// Miscellaneous.logEvent("i", "SSL Keystore", context.getCacheDir().toString(), 4); +// InputStream is = context.getResources().openRawResource(R.raw.keystore); +// keyStore.load(is,keystorePass); +// +// ctx.init(null, tmf.getTrustManagers(), null); +// } +// else +// { + KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType()); + trustStore.load(null, null); + ssf = new MySSLSocketFactoryInsecure(trustStore); + ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); + ctx.init(null, null, null); +// } + + ClientConnectionManager ccm = client.getConnectionManager(); + SchemeRegistry sr = ccm.getSchemeRegistry(); + +// if(!Settings.httpAcceptAllCertificates) + sr.register(new Scheme("https", ssf, 443)); +// else +// sr.register(new Scheme("https", ssfI, 443)); + + return new DefaultHttpClient(ccm, client.getParams()); + } + catch (Exception ex) + { + ex.printStackTrace(); + return null; + } + } + + public static void startOtherActivity(String param) + { + Miscellaneous.logEvent("i", "StartOtherActivity", "Starting other Activity...", 4); + + String packageName, className; + String params[] = param.split(";"); + packageName = params[0]; + className = params[1]; + + try + { + Miscellaneous.logEvent("i", "StartOtherApp", "Starting " + packageName + " " + className, 3); + Intent externalActivityIntent = new Intent(Intent.ACTION_MAIN); + externalActivityIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + externalActivityIntent.addCategory(Intent.CATEGORY_LAUNCHER); + externalActivityIntent.setClassName(packageName, className); + + // has intent values to deliver + for(int i=2; i 0) + duration = String.valueOf(awakeTime) + " milliseconds"; + + Miscellaneous.logEvent("i", "wakeupDevice", "wakeupDevice for " + String.valueOf(duration) + ".", 4); + + if(awakeTime > 0) + { + /* + * This action needs to be performed in a separate thread. If it ran in the same one + * the screen would turn on, the specified amount of time would pass and the screen + * would turn off again before any other action in the rule would be ran. + */ + Thread t = new Thread(new WakeUpDeviceClass(awakeTime)); + t.start(); + } + } + + public static void sendTextMessage(Context context, String[] parametersArray) + { + String phoneNumber, message; + + phoneNumber = parametersArray[0]; + message = parametersArray[1]; + + try + { + String textToSend = Miscellaneous.replaceVariablesInText(message, context); + + /* + Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("sms:" + phoneNumber)); + intent.putExtra("sms_body", message); + AutomationService.getInstance().startActivity(intent); + */ + + PendingIntent pi = PendingIntent.getActivity(context, 0, new Intent(context, Actions.class), 0); + SmsManager sms = SmsManager.getDefault(); + sms.sendTextMessage(phoneNumber, null, message, pi, null); + } + catch(Exception e) + { + Miscellaneous.logEvent("e", Miscellaneous.getAnyContext().getString(R.string.sendTextMessage), "Error in sendTextMessage: " + Log.getStackTraceString(e), 3); + } + } + + private static class WakeUpDeviceClass implements Runnable + { + private long awakeTime; + + public WakeUpDeviceClass(long awakeTime) + { + super(); + this.awakeTime = awakeTime; + } + + @Override + public void run() + { + PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE); + WakeLock wakeLock = pm.newWakeLock((WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON | PowerManager.FULL_WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP), "Automation:Wakelock"); + wakeLock.acquire(); + + try + { + Thread.sleep(awakeTime); + } + catch (InterruptedException e) + { + Miscellaneous.logEvent("w", context.getResources().getString(R.string.wakeupDevice), "Error keeping device awake: " + Log.getStackTraceString(e), 4); + } + + wakeLock.release(); + } + } + + @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1) + @SuppressLint("NewApi") + public static boolean setAirplaneMode(boolean desiredState, boolean toggleActionIfPossible) + { + // Beginning from SDK Version 17 this may not work anymore. + // Setting airplane_mode_on has moved from android.provider.Settings.System to android.provider.Settings.Global, value is unchanged. + + boolean returnValue = false; + + try + { + boolean isEnabled = ConnectivityReceiver.isAirplaneMode(autoMationServerRef); + + if(isEnabled) + Miscellaneous.logEvent("i", "Airplane mode", "Current status is enabled.", 4); + else + Miscellaneous.logEvent("i", "Airplane mode", "Current status is disabled.", 4); + + if(toggleActionIfPossible) + { + Miscellaneous.logEvent("i", "Airplane mode", context.getResources().getString(R.string.toggling), 4); + desiredState = !isEnabled; + } + + if(isEnabled != desiredState) + { + int desiredValueInt = 0; + + if(desiredState) + desiredValueInt = 1; + + if(Build.VERSION.SDK_INT < 17) + { + returnValue = android.provider.Settings.System.putInt(context.getContentResolver(), android.provider.Settings.System.AIRPLANE_MODE_ON, desiredValueInt); + } + else + { + if(desiredState) + { + String[] commands = new String[] + { + "settings put global airplane_mode_on 1", + "am broadcast -a android.intent.action.AIRPLANE_MODE --ez state true" + }; + returnValue = executeCommandViaSu(commands); + } + else + { + + String[] commands = new String[] + { + "settings put global airplane_mode_on 0", + "am broadcast -a android.intent.action.AIRPLANE_MODE --ez state false" + }; + returnValue = executeCommandViaSu(commands); + } + +// returnValue = android.provider.Settings.Global.putString(context.getContentResolver(), "airplane_mode_on", String.valueOf(desiredValueInt)); + } + + // Post an intent to reload + Intent intent = new Intent(Intent.ACTION_AIRPLANE_MODE_CHANGED); + intent.putExtra("state", !isEnabled); + context.sendBroadcast(intent); + } + else + Miscellaneous.logEvent("i", "Airplane mode", "Airplane mode is already in status " + String.valueOf(desiredState) + ". Nothing to do.", 3); + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "Airplane mode", Log.getStackTraceString(e), 2); + } + + return returnValue; + } + + /** + * Toggles the device between the different types of networks. + * Might not work. It seems only system apps are allowed to do this. + */ + public static boolean setNetworkType(int desiredType) + { + Miscellaneous.logEvent("i", "setNetworkType", "Asked to set network type to: " + String.valueOf(desiredType), 3); + if(desiredType > 0) + { + try + { + ConnectivityManager connManager = (ConnectivityManager) Miscellaneous.getAnyContext().getSystemService(context.CONNECTIVITY_SERVICE); + + // TelephonyManager.NETWORK_TYPE_EDGE + + if(connManager.getNetworkPreference() == desiredType) + { + Miscellaneous.logEvent("i", "setNetworkType", "Desired networkType already set. Not doing anything.", 4); + } + else + { + Miscellaneous.logEvent("i", "setNetworkType", "Setting network type to: " + String.valueOf(desiredType), 3); + connManager.setNetworkPreference(desiredType); + } + return true; + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "setNetworkType", "Error changing network type: " + Log.getStackTraceString(e), 2); + return false; + } + } + else + { + Miscellaneous.logEvent("w", "setNetworkType", "Invalid type of network specified: " + String.valueOf(desiredType), 4); + return false; + } + } + + public static void speakText(String parameter2) + { + try + { + String textToSpeak = Miscellaneous.replaceVariablesInText(parameter2, context); + autoMationServerRef.speak(textToSpeak, true); + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "Speak text", "Error in speak text: " + Log.getStackTraceString(e), 3); + } + } + + @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1) + public static boolean playMusic(boolean desiredState, boolean toggleActionIfPossible) + { + try + { + //TODO:toggle + // if(desiredState) + // { + Miscellaneous.logEvent("e", "Play music", "Starting music player...", 3); + + String deviceName = Build.MODEL; + /* + * Fix for Samsung devices: http://stackoverflow.com/questions/12532207/open-music-player-on-galaxy-s3 + */ + if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1 | deviceName.contains("SM-")) + playMusicIntent = new Intent(Intent.CATEGORY_APP_MUSIC); + else + playMusicIntent = new Intent(MediaStore.INTENT_ACTION_MUSIC_PLAYER); + + playMusicIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + context.startActivity(playMusicIntent); + + // playMusicIntent = new Intent(); + // playMusicIntent.setAction(android.content.Intent.ACTION_VIEW); + // File file = new File(YOUR_SONG_URI); + // playMusicIntent.setDataAndType(Uri.fromFile(file), "audio/*"); + // context.startActivity(playMusicIntent); + + return true; + // } + // else + // { + // if(playMusicIntent != null) + // { + // context.stopService(playMusicIntent); + // } + // } + + // return false; + } + catch(ActivityNotFoundException e) + { + Toast.makeText(context, "Error: No music player found.", Toast.LENGTH_LONG).show(); + Miscellaneous.logEvent("e", "Play music", "Error in playerMusic(): No music player found. " + Log.getStackTraceString(e), 3); + return false; + } + catch(Exception e) + { + Toast.makeText(context, "Error starting music player.", Toast.LENGTH_LONG).show(); + Miscellaneous.logEvent("e", "Play music", "Error in playerMusic(): " + Log.getStackTraceString(e), 3); + return false; + } + } + + private String getTransactionCode() + { + try + { + TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); + Class telephonyManagerClass = Class.forName(telephonyManager.getClass().getName()); + Method getITelephonyMethod = telephonyManagerClass.getDeclaredMethod("getITelephony"); + getITelephonyMethod.setAccessible(true); + Object ITelephonyStub = getITelephonyMethod.invoke(telephonyManager); + Class ITelephonyClass = Class.forName(ITelephonyStub.getClass().getName()); + + Class stub = ITelephonyClass.getDeclaringClass(); + Field field = stub.getDeclaredField("TRANSACTION_setDataEnabled"); + field.setAccessible(true); + return String.valueOf(field.getInt(null)); + } + catch (Exception e) + { + if (Build.VERSION.SDK_INT >= 22) + return "86"; + else if (Build.VERSION.SDK_INT == 21) + return "83"; + } + return ""; + } + + private static String getTransactionCodeFromApi20(Context context) throws Exception + { + try + { + final TelephonyManager mTelephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); + final Class mTelephonyClass = Class.forName(mTelephonyManager.getClass().getName()); + final Method mTelephonyMethod = mTelephonyClass.getDeclaredMethod("getITelephony"); + mTelephonyMethod.setAccessible(true); + final Object mTelephonyStub = mTelephonyMethod.invoke(mTelephonyManager); + final Class mTelephonyStubClass = Class.forName(mTelephonyStub.getClass().getName()); + final Class mClass = mTelephonyStubClass.getDeclaringClass(); + final Field field = mClass.getDeclaredField("TRANSACTION_setDataEnabled"); + field.setAccessible(true); + return String.valueOf(field.getInt(null)); + } + catch (Exception e) + { + // The "TRANSACTION_setDataEnabled" field is not available, + // or named differently in the current API level, so we throw + // an exception and inform users that the method is not available. + throw e; + } + } + + public static class MobileDataStuff + { + /** + * Turns data on and off. + * Requires root permissions from lollipop on. + * @param toggleActionIfPossible + */ + public static boolean setDataConnection(boolean desiredState, boolean toggleActionIfPossible) + { + Miscellaneous.logEvent("i", "setData", "Asked to turn data to: " + String.valueOf(desiredState), 3); + + try + { + ConnectivityManager connManager = (ConnectivityManager) Miscellaneous.getAnyContext().getSystemService(Miscellaneous.getAnyContext().CONNECTIVITY_SERVICE); + final Class conmanClass = Class.forName(connManager.getClass().getName()); + final Field iConnectivityManagerField = conmanClass.getDeclaredField("mService"); + iConnectivityManagerField.setAccessible(true); + final Object iConnectivityManager = iConnectivityManagerField.get(connManager); + final Class iConnectivityManagerClass = Class.forName(iConnectivityManager.getClass().getName()); + + Boolean isEnabled = isMobileDataEnabled(); + + if(toggleActionIfPossible) + { + context.getResources().getString(R.string.toggling); + desiredState = !isEnabled; + } + +// if(isEnabled != desiredState) +// { + if(Build.VERSION.SDK_INT <= 20) + { + for(Method m : iConnectivityManagerClass.getDeclaredMethods()) + { + Miscellaneous.logEvent("i", "method", m.getName(), 5); + } + + final Method setMobileDataEnabledMethod = iConnectivityManagerClass.getDeclaredMethod("setMobileDataEnabled", Boolean.TYPE); + setMobileDataEnabledMethod.setAccessible(true); + + setMobileDataEnabledMethod.invoke(iConnectivityManager, desiredState); + } + else + { + return setDataConnectionWithRoot(desiredState); + } +// } +// else +// { +// Miscellaneous.logEvent("i", "setData", "Data already set to " + String.valueOf(desiredState) + ". Not doing anything.", 4); +// } + + return true; + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "setData", "Error changing network type: " + Log.getStackTraceString(e), 2); + return false; + } + } + + protected static boolean setDataConnectionWithRoot(boolean enable) + { + try + { + int desiredState = 0; + if(enable) + desiredState = 1; + + if(MobileDataStuff.setMobileNetworkfromLollipop(desiredState, autoMationServerRef)) + { + Miscellaneous.logEvent("i", "setDataConnectionWithRoot()", Miscellaneous.getAnyContext().getResources().getString(R.string.dataConWithRootSuccess), 2); + return true; + } + else + { + Miscellaneous.logEvent("e", "setDataConnectionWithRoot()", Miscellaneous.getAnyContext().getResources().getString(R.string.dataConWithRootFail), 2); + return false; + } + } + catch(Exception e) + { + String rootString; + if(Miscellaneous.isPhoneRooted()) + rootString = Miscellaneous.getAnyContext().getResources().getString(R.string.phoneIsRooted); + else + rootString = Miscellaneous.getAnyContext().getResources().getString(R.string.phoneIsNotRooted); + + Miscellaneous.logEvent("e", "setDataWithRoot()", "Error setting data setting with root. " + rootString + ": " + Log.getStackTraceString(e), 3); + return false; + } + } + + @SuppressLint("NewApi") + public static boolean setMobileNetworkfromLollipop(int desiredState, Context context) throws Exception + { + String command = null; + int state = 0; + + try + { + // Get the current state of the mobile network. + state = isMobileDataEnabled() ? 0 : 1; + // Get the value of the "TRANSACTION_setDataEnabled" field. + String transactionCode = getTransactionCode(context); + // Android 5.1+ (API 22) and later. + if (Build.VERSION.SDK_INT > Build.VERSION_CODES.LOLLIPOP) + { + SubscriptionManager mSubscriptionManager = (SubscriptionManager) context.getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE); + // Loop through the subscription list i.e. SIM list. + for (int i = 0; i < mSubscriptionManager.getActiveSubscriptionInfoCountMax(); i++) + { + if (transactionCode != null && transactionCode.length() > 0) + { + // Get the active subscription ID for a given SIM card. + int subscriptionId = mSubscriptionManager.getActiveSubscriptionInfoList().get(i).getSubscriptionId(); + // Execute the command via `su` to turn off + // mobile network for a subscription service. + command = "service call phone " + transactionCode + " i32 " + subscriptionId + " i32 " + desiredState; + Miscellaneous.logEvent("i", "setDataConnectionWithRoot()", "Running command: " + command.toString(), 5); + return executeCommandViaSu(new String[] { command }); + } + } + } + else if (Build.VERSION.SDK_INT == Build.VERSION_CODES.LOLLIPOP) + { + // Android 5.0 (API 21) only. + if (transactionCode != null && transactionCode.length() > 0) + { + // Execute the command via `su` to turn off mobile network. + command = "service call phone " + transactionCode + " i32 " + desiredState; + return executeCommandViaSu(new String[] { command }); + } + } + } + catch(Exception e) + { + // Oops! Something went wrong, so we throw the exception here. + throw e; + } + + return false; + } + + @SuppressLint("NewApi") + public static boolean isMobileDataEnabled() + { + boolean isEnabled = false; + + if(Build.VERSION.SDK_INT <= 20) + { + try + { + ConnectivityManager connManager = (ConnectivityManager) Miscellaneous.getAnyContext().getSystemService(Miscellaneous.getAnyContext().CONNECTIVITY_SERVICE); + final Class conmanClass = Class.forName(connManager.getClass().getName()); + final Field iConnectivityManagerField = conmanClass.getDeclaredField("mService"); + iConnectivityManagerField.setAccessible(true); + final Object iConnectivityManager = iConnectivityManagerField.get(connManager); + final Class iConnectivityManagerClass = Class.forName(iConnectivityManager.getClass().getName()); + + Method getMobileDataEnabledMethod = null; + for(Method m : iConnectivityManagerClass.getDeclaredMethods()) + { + Miscellaneous.logEvent("i", "Methods", m.getName(), 5); + if(m.getName().equals("getMobileDataEnabled")) + { + getMobileDataEnabledMethod = m; + break; + } + } + // final Method getMobileDataEnabledMethod = iConnectivityManagerClass.getDeclaredMethod("getMobileDataEnabled", null); + + getMobileDataEnabledMethod.setAccessible(true); + + isEnabled = (Boolean) getMobileDataEnabledMethod.invoke(iConnectivityManager, (Object[]) null); + } + catch (Exception e) + { + Miscellaneous.logEvent("e", "isMobileDataEnabled()", "Error checking if mobile data is enabled: " + Log.getStackTraceString(e), 3); + } + } + else + { + isEnabled = android.provider.Settings.Global.getInt(context.getContentResolver(), "mobile_data", 0) == 1; + } + + return isEnabled; + } + + private static String getTransactionCode(Context context) throws Exception + { + try + { + final TelephonyManager mTelephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); + final Class mTelephonyClass = Class.forName(mTelephonyManager.getClass().getName()); + final Method mTelephonyMethod = mTelephonyClass.getDeclaredMethod("getITelephony"); + mTelephonyMethod.setAccessible(true); + final Object mTelephonyStub = mTelephonyMethod.invoke(mTelephonyManager); + final Class mTelephonyStubClass = Class.forName(mTelephonyStub.getClass().getName()); + final Class mClass = mTelephonyStubClass.getDeclaringClass(); + final Field field = mClass.getDeclaredField("TRANSACTION_setDataEnabled"); + field.setAccessible(true); + return String.valueOf(field.getInt(null)); + } + catch (Exception e) + { + // The "TRANSACTION_setDataEnabled" field is not available, + // or named differently in the current API level, so we throw + // an exception and inform users that the method is not available. + throw e; + } + } + } + + protected static boolean executeCommandViaSu(String[] commands) + { + boolean success = false; + + try + { + suAvailable = Shell.SU.available(); + if (suAvailable) + { + suVersion = Shell.SU.version(false); + suVersionInternal = Shell.SU.version(true); + suResult = Shell.SU.run(commands); + + if(suResult != null) + success = true; + } + } + catch (Exception e) + { + success = false; + } + + return success; + } + + public static void setScreenBrightness(boolean autoBrightness, int brightnessValue) + { + if(autoBrightness) + android.provider.Settings.System.putInt(context.getContentResolver(), android.provider.Settings.System.SCREEN_BRIGHTNESS_MODE, android.provider.Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC); + else + android.provider.Settings.System.putInt(context.getContentResolver(), android.provider.Settings.System.SCREEN_BRIGHTNESS_MODE, android.provider.Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL); + + int actualBrightnessValue = (int)((float)brightnessValue / 100.0 * 255.0); + android.provider.Settings.System.putInt(context.getContentResolver(), android.provider.Settings.System.SCREEN_BRIGHTNESS, actualBrightnessValue); + } +} diff --git a/app/src/main/java/com/jens/automation2/ActivityEditSendTextMessage.java b/app/src/main/java/com/jens/automation2/ActivityEditSendTextMessage.java new file mode 100644 index 0000000..8c3307a --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivityEditSendTextMessage.java @@ -0,0 +1,181 @@ +package com.jens.automation2; + +import android.app.Activity; +import android.content.Intent; +import android.content.pm.PackageManager; +import android.database.Cursor; +import android.net.Uri; +import android.os.Build; +import android.os.Bundle; +import android.provider.ContactsContract; +import android.view.View; +import android.view.View.OnClickListener; +import android.widget.Button; +import android.widget.EditText; +import android.widget.Toast; + +import androidx.annotation.NonNull; + +import com.jens.automation2.Action.Action_Enum; + + +public class ActivityEditSendTextMessage extends Activity +{ + Button bSaveSendTextMessage, bImportNumberFromContacts; + EditText etPhoneNumber, etSendTextMessage; + + protected final static int requestCodeForContactsPermissions = 9876; + +// private String existingUrl = ""; + + public static boolean edit = false; + public static Action resultingAction = null; + + @Override + protected void onCreate(Bundle savedInstanceState) + { + super.onCreate(savedInstanceState); + this.setContentView(R.layout.send_textmessage_editor); + + etSendTextMessage = (EditText)findViewById(R.id.etSendTextMessage); + etPhoneNumber = (EditText)findViewById(R.id.etPhoneNumber); + bSaveSendTextMessage = (Button)findViewById(R.id.bSaveSendTextMessage); + bImportNumberFromContacts = (Button)findViewById(R.id.bImportNumberFromContacts); + + bSaveSendTextMessage.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + if(etSendTextMessage.getText().toString().length() > 0 && etPhoneNumber.getText().toString().length() > 0) + { + if(resultingAction == null) + { + resultingAction = new Action(); + resultingAction.setAction(Action_Enum.sendTextMessage); + resultingAction.setParameter2(etPhoneNumber.getText().toString() + Actions.smsSeparator + etSendTextMessage.getText().toString()); + } + backToRuleManager(); + } + else + Toast.makeText(getBaseContext(), getResources().getString(R.string.textTooShort), Toast.LENGTH_LONG).show(); + } + }); + + bImportNumberFromContacts.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View view) + { + if(!ActivityPermissions.havePermission("android.permission.READ_CONTACTS", ActivityEditSendTextMessage.this)) + { + requestPermissions("android.permission.READ_CONTACTS"); + } + else + openContactsDialogue(); + } + }); + + ActivityEditSendTextMessage.edit = getIntent().getBooleanExtra("edit", false); + if(edit) + { + String[] parameters = ActivityEditSendTextMessage.resultingAction.getParameter2().split(Actions.smsSeparator); + etPhoneNumber.setText(parameters[0]); + etSendTextMessage.setText(parameters[1]); + } + + +// String url = getIntent().getStringExtra("urlToTrigger"); +// if(url != null) +// existingUrl = url; + } + + private void backToRuleManager() + { +// Intent returnIntent = new Intent(); +// returnIntent.putExtra("urlToTrigger", existingUrl); + +// setResult(RESULT_OK, returnIntent); + + if(edit && resultingAction != null) + { + ActivityEditSendTextMessage.resultingAction.setParameter2(etPhoneNumber.getText().toString() + Actions.smsSeparator + etSendTextMessage.getText().toString()); + } + + setResult(RESULT_OK); + + this.finish(); + } + protected void requestPermissions(String... requiredPermissions) + { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) + { + if(requiredPermissions.length > 0) + { + StringBuilder permissions = new StringBuilder(); + for (String perm : requiredPermissions) + permissions.append(perm + "; "); + if (permissions.length() > 0) + permissions.delete(permissions.length() - 2, permissions.length()); + + Miscellaneous.logEvent("i", "Permissions", "Requesting permissions: " + permissions, 2); + + requestPermissions(requiredPermissions, requestCodeForContactsPermissions); + } + } + } + + @Override + public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) + { + if(requestCode == requestCodeForContactsPermissions) + { + for(int i=0; i0) + { + if(resultingAction == null) + { + resultingAction = new Action(); + resultingAction.setAction(Action_Enum.speakText); + resultingAction.setParameter2(etSpeakText.getText().toString()); + } + backToRuleManager(); + } + else + Toast.makeText(getBaseContext(), getResources().getString(R.string.textTooShort), Toast.LENGTH_LONG).show(); + } + }); + + ActivityEditSpeakText.edit = getIntent().getBooleanExtra("edit", false); + if(edit) + etSpeakText.setText(ActivityEditSpeakText.resultingAction.getParameter2()); + + +// String url = getIntent().getStringExtra("urlToTrigger"); +// if(url != null) +// existingUrl = url; + } + + private void backToRuleManager() + { +// Intent returnIntent = new Intent(); +// returnIntent.putExtra("urlToTrigger", existingUrl); + +// setResult(RESULT_OK, returnIntent); + + if(edit && resultingAction != null) + ActivityEditSpeakText.resultingAction.setParameter2(etSpeakText.getText().toString()); + + setResult(RESULT_OK); + + this.finish(); + } + +} diff --git a/app/src/main/java/com/jens/automation2/ActivityEditTriggerUrl.java b/app/src/main/java/com/jens/automation2/ActivityEditTriggerUrl.java new file mode 100644 index 0000000..fc3fc54 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivityEditTriggerUrl.java @@ -0,0 +1,171 @@ +package com.jens.automation2; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.View.OnClickListener; +import android.widget.AdapterView; +import android.widget.AdapterView.OnItemLongClickListener; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.CheckBox; +import android.widget.CompoundButton; +import android.widget.CompoundButton.OnCheckedChangeListener; +import android.widget.EditText; +import android.widget.ListView; +import android.widget.TableLayout; +import android.widget.Toast; + +import com.jens.automation2.Action.Action_Enum; + +import java.util.Map; + +public class ActivityEditTriggerUrl extends Activity +{ + Button bSaveTriggerUrl; + EditText etTriggerUrl, etTriggerUrlUsername, etTriggerUrlPassword; + ListView lvTriggerUrlPostParameters; + CheckBox chkTriggerUrlUseAuthentication; + TableLayout tlTriggerUrlAuthentication; + + ArrayAdapter> lvTriggerUrlPostParametersAdapter; + +// private String existingUrl = ""; + + public static boolean edit = false; + public static Action resultingAction = null; + + @Override + protected void onCreate(Bundle savedInstanceState) + { + super.onCreate(savedInstanceState); + this.setContentView(R.layout.trigger_url_editor); + + etTriggerUrl = (EditText)findViewById(R.id.etTriggerUrl); + etTriggerUrlUsername = (EditText)findViewById(R.id.etTriggerUrlUsername); + etTriggerUrlPassword = (EditText)findViewById(R.id.etTriggerUrlPassword); + chkTriggerUrlUseAuthentication = (CheckBox)findViewById(R.id.chkTriggerUrlUseAuthentication); + lvTriggerUrlPostParameters = (ListView)findViewById(R.id.lvTriggerUrlPostParameters); + tlTriggerUrlAuthentication = (TableLayout)findViewById(R.id.tlTriggerUrlAuthentication); + bSaveTriggerUrl = (Button)findViewById(R.id.bSaveTriggerUrl); + bSaveTriggerUrl.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + if(etTriggerUrl.getText().toString().length() > 0) + { + if(resultingAction == null) + { + resultingAction = new Action(); + resultingAction.setAction(Action_Enum.triggerUrl); + resultingAction.setParameter1(chkTriggerUrlUseAuthentication.isChecked()); + + String username = etTriggerUrlUsername.getText().toString(); + String password = etTriggerUrlPassword.getText().toString(); + + if(username == null) + username = ""; + + if(password == null) + password = ""; + + ActivityEditTriggerUrl.resultingAction.setParameter2( + username + ";" + + password + ";" + + etTriggerUrl.getText().toString().trim() + ); + } + backToRuleManager(); + } + else + Toast.makeText(getBaseContext(), getResources().getString(R.string.urlTooShort), Toast.LENGTH_LONG).show(); + } + }); + + + chkTriggerUrlUseAuthentication.setOnCheckedChangeListener(new OnCheckedChangeListener() + { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) + { + if(isChecked) + tlTriggerUrlAuthentication.setVisibility(View.VISIBLE); + else + tlTriggerUrlAuthentication.setVisibility(View.GONE); + + etTriggerUrlUsername.setEnabled(isChecked); + etTriggerUrlPassword.setEnabled(isChecked); + } + }); + + lvTriggerUrlPostParameters.setOnItemLongClickListener(new OnItemLongClickListener() + { + @Override + public boolean onItemLongClick(AdapterView arg0, View arg1, int arg2, long arg3) + { + return false; + } + }); + updateListView(); + + + ActivityEditTriggerUrl.edit = getIntent().getBooleanExtra("edit", false); + if(edit) + { + // username,password,URL + String[] components = ActivityEditTriggerUrl.resultingAction.getParameter2().split(";"); + + if(components.length >= 3) + { + etTriggerUrl.setText(components[2]); + chkTriggerUrlUseAuthentication.setChecked(ActivityEditTriggerUrl.resultingAction.getParameter1()); + etTriggerUrlUsername.setText(components[0]); + etTriggerUrlPassword.setText(components[1]); + } + else + etTriggerUrl.setText(components[0]); + } + } + + private void backToRuleManager() + { + if(edit && resultingAction != null) + { + String username = etTriggerUrlUsername.getText().toString(); + String password = etTriggerUrlPassword.getText().toString(); + + if(username == null) + username = ""; + + if(password == null) + password = ""; + + ActivityEditTriggerUrl.resultingAction.setParameter1(chkTriggerUrlUseAuthentication.isChecked()); + + ActivityEditTriggerUrl.resultingAction.setParameter2( + username + ";" + + password + ";" + + etTriggerUrl.getText().toString() + ); + } + + setResult(RESULT_OK); + + this.finish(); + } + + private void updateListView() + { + Miscellaneous.logEvent("i", "ListView", "Attempting to update lvTriggerUrlPostParameters", 4); + try + { + if(lvTriggerUrlPostParameters.getAdapter() == null) + lvTriggerUrlPostParameters.setAdapter(lvTriggerUrlPostParametersAdapter); + + lvTriggerUrlPostParametersAdapter.notifyDataSetChanged(); + } + catch(NullPointerException e) + {} + } +} diff --git a/app/src/main/java/com/jens/automation2/ActivityGeneric.java b/app/src/main/java/com/jens/automation2/ActivityGeneric.java new file mode 100644 index 0000000..ab1e3fc --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivityGeneric.java @@ -0,0 +1,67 @@ +package com.jens.automation2; + +import android.app.Activity; +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.content.ServiceConnection; +import android.os.IBinder; +import android.util.Log; + +import com.jens.automation2.AutomationService.LocalBinder; + +public class ActivityGeneric extends Activity +{ + public static Intent myServiceIntent = null; + AutomationService myAutomationService = null; + boolean boundToService = false; + + public void storeServiceReferenceInVariable() + { + if(AutomationService.isMyServiceRunning(getApplicationContext()) && myAutomationService == null) + { + bindToService(); + } + } + + public void bindToService() + { + Log.i("service", "binding to service"); + if(!boundToService) + { +// if(myServiceIntent == null) + myServiceIntent = new Intent(this, AutomationService.class); + + Miscellaneous.logEvent("i", "Service", getResources().getString(R.string.logAttemptingToBindToService) + String.valueOf(bindService(myServiceIntent, myServiceConnection, Context.BIND_AUTO_CREATE)), 5); + } + } + public void unBindFromService() + { + Miscellaneous.logEvent("i", "Service", getResources().getString(R.string.logAttemptingToUnbindFromService), 5); + if(boundToService) + { + unbindService(myServiceConnection); + boundToService = false; + Miscellaneous.logEvent("i", "Service", getResources().getString(R.string.logUnboundFromService), 5); + } + } + + private ServiceConnection myServiceConnection = new ServiceConnection() + { + @Override + public void onServiceConnected(ComponentName name, IBinder service) + { + Miscellaneous.logEvent("i", "Service", getResources().getString(R.string.logBoundToService), 5); + LocalBinder binder = (LocalBinder)service; + myAutomationService = binder.getService(); + boundToService = true; + } + + @Override + public void onServiceDisconnected(ComponentName name) + { + Miscellaneous.logEvent("i", "Service", getResources().getString(R.string.logUnboundFromService), 5); + boundToService = false; + } + }; +} diff --git a/app/src/main/java/com/jens/automation2/ActivityHelp.java b/app/src/main/java/com/jens/automation2/ActivityHelp.java new file mode 100644 index 0000000..9a4f849 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivityHelp.java @@ -0,0 +1,23 @@ +package com.jens.automation2; + +import android.app.Activity; +import android.os.Bundle; +import android.text.method.LinkMovementMethod; +import android.widget.TextView; + +import com.jens.automation2.R.layout; + +public class ActivityHelp extends Activity +{ + + @Override + protected void onCreate(Bundle savedInstanceState) + { + super.onCreate(savedInstanceState); + setContentView(layout.help_text); + + TextView tvHelpTextEnergySaving = (TextView) findViewById(R.id.tvHelpTextEnergySaving); + tvHelpTextEnergySaving.setMovementMethod(LinkMovementMethod.getInstance()); + } + +} diff --git a/app/src/main/java/com/jens/automation2/ActivityMainPoi.java b/app/src/main/java/com/jens/automation2/ActivityMainPoi.java new file mode 100644 index 0000000..d5ed26a --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivityMainPoi.java @@ -0,0 +1,201 @@ +package com.jens.automation2; + +import android.app.AlertDialog; +import android.content.DialogInterface; +import android.content.Intent; +import android.os.Bundle; +import android.view.View; +import android.view.View.OnClickListener; +import android.widget.AdapterView; +import android.widget.AdapterView.OnItemLongClickListener; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.ListView; +import android.widget.Toast; + +import com.jens.automation2.AutomationService.serviceCommands; + +public class ActivityMainPoi extends ActivityGeneric +{ + private Button bAddPoi; + ListView poiListView; + + ArrayAdapter poiListViewAdapter; + + AutomationService myAutomationService; + boolean boundToService = false; + + protected static ActivityMainPoi instance = null; + + public static PointOfInterest poiToEdit; + + protected final static int requestCodeForPermission = 1002; + + public static ActivityMainPoi getInstance() + { + if(instance == null) + instance = new ActivityMainPoi(); + + return instance; + } + + @Override + protected void onCreate(Bundle savedInstanceState) + { + super.onCreate(savedInstanceState); + setContentView(R.layout.main_poi_layout); + + instance = this; + + bAddPoi = (Button)findViewById(R.id.bAddPoi); + bAddPoi.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + if(!ActivityPermissions.havePermission(ActivityPermissions.writeExternalStoragePermissionName, ActivityMainPoi.this)) + { + Toast.makeText(ActivityMainPoi.this, getResources().getString(R.string.appRequiresPermissiontoAccessExternalStorage), Toast.LENGTH_LONG).show(); + return; + } + + if(!ActivityPermissions.havePermission(ActivityPermissions.permissionNameLocationCoarse, ActivityMainPoi.this) || !ActivityPermissions.havePermission(ActivityPermissions.permissionNameLocationFine, ActivityMainPoi.this)) + { + Intent permissionIntent = new Intent(ActivityMainPoi.this, ActivityPermissions.class); + + permissionIntent.putExtra(ActivityPermissions.intentExtraName, new String[] { ActivityPermissions.permissionNameLocationCoarse, ActivityPermissions.permissionNameLocationFine }); + + startActivityForResult(permissionIntent, requestCodeForPermission); + } + else + { + buttonAddPoi(); + } + } + }); + + poiListView = (ListView)findViewById(R.id.lvPoiList); + + poiListViewAdapter = new ArrayAdapter(this, R.layout.text_view_for_poi_listview_mediumtextsize, PointOfInterest.getPointOfInterestCollection()); + poiListView.setClickable(true); + /*poiListView.setOnItemClickListener(new AdapterView.OnItemClickListener() + { + @Override + public void onItemClick(AdapterView arg0, View arg1, int arg2, long arg3) + { + poiToEdit = (PointOfInterest)poiListViewAdapter.getItem(arg2); + Intent manageSpecificPoiIntent = new Intent (ActivityMainPoi.this, ActivityManageSpecificPoi.class); + manageSpecificPoiIntent.putExtra("action", "change"); + startActivityForResult(manageSpecificPoiIntent, 2000); + } + });*/ + poiListView.setOnItemLongClickListener(new OnItemLongClickListener() + { + @Override + public boolean onItemLongClick(AdapterView arg0, View arg1, int arg2, long arg3) + { + getPoiOptionsDialog((PointOfInterest)poiListView.getItemAtPosition(arg2)).show(); + return false; + } + }); + + updateListView(); + + this.storeServiceReferenceInVariable(); + } + + private void buttonAddPoi() + { + poiToEdit = null; + Intent manageSpecificPoiIntent = new Intent(ActivityMainPoi.this, ActivityManageSpecificPoi.class); + manageSpecificPoiIntent.putExtra("action", "create"); + startActivityForResult(manageSpecificPoiIntent, 1000); + } + + public void updateListView() + { + Miscellaneous.logEvent("i", "ListView", "Attempting to update PoiListView", 5); + try + { + if(poiListView.getAdapter() == null) + poiListView.setAdapter(poiListViewAdapter); + + poiListViewAdapter.notifyDataSetChanged(); + } + catch(NullPointerException e) + {} + } + + @Override + protected void onActivityResult(int requestCode, int resultCode, Intent data) + { + super.onActivityResult(requestCode, resultCode, data); + + if(AutomationService.isMyServiceRunning(this)) + bindToService(); + + switch(requestCode) + { + case 1000: //add Poi +// poiToEdit = null; //clear cache + updateListView(); + break; + case 2000://edit Poi + poiToEdit = null; //clear cache + updateListView(); + break; + case requestCodeForPermission: + if(resultCode == RESULT_OK) + buttonAddPoi(); + break; + } + + if(boundToService && AutomationService.isMyServiceRunning(this)) + { + myAutomationService.serviceInterface(serviceCommands.updateNotification); //in case names got changed. + unBindFromService(); + } + } + + private AlertDialog getPoiOptionsDialog(final PointOfInterest pointOfInterest) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this); + alertDialogBuilder.setTitle(getResources().getString(R.string.whatToDoWithPoi)); + alertDialogBuilder.setItems(new String[]{ getResources().getString(R.string.edit), getResources().getString(R.string.deleteCapital) }, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + switch(which) + { + /*case 0: + if(AutomationService.isMyServiceRunning(ActivityMainPoi.this)) + { + AutomationService runContext = AutomationService.getInstance(); + if(runContext != null) + { + pointOfInterest.activate(runContext); + break; + } + } + Toast.makeText(ActivityMainPoi.this, getResources().getString(R.string.serviceHasToRunForThat), Toast.LENGTH_LONG).show(); + break;*/ + case 0: + poiToEdit = pointOfInterest; + Intent manageSpecificPoiIntent = new Intent (ActivityMainPoi.this, ActivityManageSpecificPoi.class); + manageSpecificPoiIntent.putExtra("action", "change"); + startActivityForResult(manageSpecificPoiIntent, 2000); + break; + case 1: + if(pointOfInterest.delete(Miscellaneous.getAnyContext())) + updateListView(); + break; + } + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + +} diff --git a/app/src/main/java/com/jens/automation2/ActivityMainProfiles.java b/app/src/main/java/com/jens/automation2/ActivityMainProfiles.java new file mode 100644 index 0000000..44f4578 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivityMainProfiles.java @@ -0,0 +1,198 @@ +package com.jens.automation2; + +import android.app.AlertDialog; +import android.content.DialogInterface; +import android.content.Intent; +import android.os.Bundle; +import android.view.View; +import android.view.View.OnClickListener; +import android.widget.AdapterView; +import android.widget.AdapterView.OnItemLongClickListener; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.ListView; +import android.widget.Toast; + +import com.jens.automation2.AutomationService.serviceCommands; + +public class ActivityMainProfiles extends ActivityGeneric +{ + private Button bAddProfile; + ListView profileListView; + + ArrayAdapter profileListViewAdapter; + + AutomationService myAutomationService; + + public static Profile profileToEdit; + + protected static ActivityMainProfiles instance = null; + + public static ActivityMainProfiles getInstance() + { + if(instance == null) + instance = new ActivityMainProfiles(); + + return instance; + } + + @Override + protected void onCreate(Bundle savedInstanceState) + { + super.onCreate(savedInstanceState); + setContentView(R.layout.main_profile_layout); + + instance = this; + + bAddProfile = (Button)findViewById(R.id.bAddProfile); + bAddProfile.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + if(!ActivityPermissions.havePermission(ActivityPermissions.writeExternalStoragePermissionName, ActivityMainProfiles.this)) + { + Toast.makeText(ActivityMainProfiles.this, getResources().getString(R.string.appRequiresPermissiontoAccessExternalStorage), Toast.LENGTH_LONG).show(); + return; + } + + profileToEdit = null; + Intent manageSpecificProfileIntent = new Intent (ActivityMainProfiles.this, ActivityManageSpecificProfile.class); + manageSpecificProfileIntent.putExtra("action", "create"); + startActivityForResult(manageSpecificProfileIntent, 1000); + } + }); + + profileListView = (ListView)findViewById(R.id.lvProfilesList); + + profileListViewAdapter = new ArrayAdapter(this, R.layout.text_view_for_poi_listview_mediumtextsize, Profile.getProfileCollection()); + profileListView.setClickable(true); + /*profileListView.setOnItemClickListener(new AdapterView.OnItemClickListener() + { + @Override + public void onItemClick(AdapterView arg0, View arg1, int arg2, long arg3) + { + profileToEdit = (Profile)profileListViewAdapter.getItem(arg2); + Intent manageSpecificProfileIntent = new Intent (ActivityMainProfiles.this, ActivityManageSpecificProfile.class); + manageSpecificProfileIntent.putExtra("action", "change"); + startActivityForResult(manageSpecificProfileIntent, 2000); + } + });*/ + profileListView.setOnItemLongClickListener(new OnItemLongClickListener() + { + @Override + public boolean onItemLongClick(AdapterView arg0, View arg1, int arg2, long arg3) + { + getProfileDialog((Profile)profileListView.getItemAtPosition(arg2)).show(); + return false; + } + }); + + if(Settings.executeRulesAndProfilesWithSingleClick) + { + profileListView.setOnItemClickListener(new AdapterView.OnItemClickListener() + { + @Override + public void onItemClick(AdapterView parent, View view, int position, long id) + { + if(AutomationService.isMyServiceRunning(ActivityMainProfiles.this)) + { + AutomationService runContext = AutomationService.getInstance(); + if(runContext != null) + { + Profile profile = (Profile)profileListView.getItemAtPosition(position); + profile.activate(runContext); + } + } + } + }); + } + + updateListView(); + + this.storeServiceReferenceInVariable(); + } + + public void updateListView() + { + Miscellaneous.logEvent("i", "ListView", "Attempting to update ProfileListView", 5); + try + { + if(profileListView.getAdapter() == null) + profileListView.setAdapter(profileListViewAdapter); + + profileListViewAdapter.notifyDataSetChanged(); + } + catch(NullPointerException e) + {} + } + + @Override + protected void onActivityResult(int requestCode, int resultCode, Intent data) + { + super.onActivityResult(requestCode, resultCode, data); + + if(AutomationService.isMyServiceRunning(this)) + bindToService(); + + if(requestCode == 1000) //add Profile + { +// profileToEdit = null; //clear cache + updateListView(); + } + + if(requestCode == 2000) //edit Profile + { + profileToEdit = null; //clear cache + updateListView(); + } + + if(boundToService && AutomationService.isMyServiceRunning(this)) + { + myAutomationService.serviceInterface(serviceCommands.updateNotification); // in case names got changed. + unBindFromService(); + } + } + + private AlertDialog getProfileDialog(final Profile profile) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this); + alertDialogBuilder.setTitle(getResources().getString(R.string.whatToDoWithProfile)); + alertDialogBuilder.setItems(new String[]{ getResources().getString(R.string.runManually), getResources().getString(R.string.edit), getResources().getString(R.string.deleteCapital) }, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + switch(which) + { + case 0: + if(AutomationService.isMyServiceRunning(ActivityMainProfiles.this)) + { + AutomationService runContext = AutomationService.getInstance(); + if(runContext != null) + { + profile.activate(runContext); + break; + } + } + Toast.makeText(ActivityMainProfiles.this, getResources().getString(R.string.serviceHasToRunForThat), Toast.LENGTH_LONG).show(); + break; + case 1: + profileToEdit = profile; + Intent manageSpecificProfileIntent = new Intent (ActivityMainProfiles.this, ActivityManageSpecificProfile.class); + manageSpecificProfileIntent.putExtra("action", "change"); + startActivityForResult(manageSpecificProfileIntent, 2000); + break; + case 2: + if(profile.delete(myAutomationService)) + updateListView(); + break; + } + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + +} diff --git a/app/src/main/java/com/jens/automation2/ActivityMainRules.java b/app/src/main/java/com/jens/automation2/ActivityMainRules.java new file mode 100644 index 0000000..1d61701 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivityMainRules.java @@ -0,0 +1,252 @@ +package com.jens.automation2; + +import android.app.AlertDialog; +import android.content.Context; +import android.content.DialogInterface; +import android.content.Intent; +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.ViewGroup; +import android.widget.AdapterView; +import android.widget.AdapterView.OnItemLongClickListener; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.ImageView; +import android.widget.ListView; +import android.widget.TextView; +import android.widget.Toast; + +import com.jens.automation2.AutomationService.serviceCommands; +import com.jens.automation2.receivers.AlarmListener; + +import java.util.ArrayList; + +public class ActivityMainRules extends ActivityGeneric +{ + private ListView ruleListView; + private ArrayAdapter ruleListViewAdapter; + public static Rule ruleToEdit; + protected static ActivityMainRules instance = null; + + public static ActivityMainRules getInstance() + { + if(instance == null) + instance = new ActivityMainRules(); + + return instance; + } + + @Override + protected void onCreate(Bundle savedInstanceState) + { + super.onCreate(savedInstanceState); + setContentView(R.layout.main_rule_layout); + + instance = this; + + Button bAddRule = (Button)findViewById(R.id.bAddRule); + bAddRule.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + if(!ActivityPermissions.havePermission(ActivityPermissions.writeExternalStoragePermissionName, ActivityMainRules.this)) + { + Toast.makeText(ActivityMainRules.this, getResources().getString(R.string.appRequiresPermissiontoAccessExternalStorage), Toast.LENGTH_LONG).show(); + return; + } + + ruleToEdit = null; + Intent startAddRuleIntent = new Intent(ActivityMainRules.this, ActivityManageSpecificRule.class); + startActivityForResult(startAddRuleIntent, 3000); + } + }); + + ruleListView = (ListView)findViewById(R.id.lvRuleList); + + ruleListViewAdapter = new RuleArrayAdapter(this, R.layout.view_for_rule_listview, Rule.getRuleCollection()); + ruleListView.setClickable(true); + + ruleListView.setOnItemLongClickListener(new OnItemLongClickListener() + { + @Override + public boolean onItemLongClick(AdapterView arg0, View arg1, int arg2, long arg3) + { + getRuleDialog((Rule)ruleListView.getItemAtPosition(arg2)).show(); + return false; + } + }); + + if(Settings.executeRulesAndProfilesWithSingleClick) + { + ruleListView.setOnItemClickListener(new AdapterView.OnItemClickListener() + { + @Override + public void onItemClick(AdapterView parent, View view, int position, long id) + { + if(AutomationService.isMyServiceRunning(ActivityMainRules.this)) + { + AutomationService runContext = AutomationService.getInstance(); + if(runContext != null) + { + Rule rule = (Rule)ruleListView.getItemAtPosition(position); + rule.activate(runContext, true); + } + } + } + }); + } + + updateListView(); + + this.storeServiceReferenceInVariable(); + } + + private static class RuleHolder + { + public ImageView ivActiveInactive; + public TextView tvRuleName; + } + + private static class RuleArrayAdapter extends ArrayAdapter + { + + public RuleArrayAdapter(Context context, int resource, ArrayList objects) + { + super(context, resource, objects); + } + + @Override + public View getView(int position, View convertView, ViewGroup parent) + { + View v = convertView; + RuleHolder holder = new RuleHolder(); + // First let's verify the convertView is not null + if (convertView == null) + { + // This a new view we inflate the new layout + LayoutInflater inflater = (LayoutInflater) this.getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE); + v = inflater.inflate(R.layout.view_for_rule_listview, null); + // Now we can fill the layout with the right values + TextView tv = (TextView) v.findViewById(R.id.tvRuleName); + ImageView img = (ImageView) v.findViewById(R.id.ivActiveInactive); + holder.tvRuleName = tv; + holder.ivActiveInactive = img; + v.setTag(holder); + } + else + holder = (RuleHolder) v.getTag(); + + System.out.println("Position ["+position+"]"); + Rule r = Rule.getRuleCollection().get(position); + holder.tvRuleName.setText(r.getName()); + if(r.isRuleActive()) + { + if (r.haveEnoughPermissions()) + holder.ivActiveInactive.setImageResource(R.drawable.status_active); + else + holder.ivActiveInactive.setImageResource(R.drawable.status_unable); + } + else + holder.ivActiveInactive.setImageResource(R.drawable.status_inactive); + + return v; + } + } + + @Override + protected void onActivityResult(int requestCode, int resultCode, Intent data) + { + super.onActivityResult(requestCode, resultCode, data); + if(AutomationService.isMyServiceRunning(this)) + bindToService(); + + if(requestCode == 3000) //add Rule + { + ruleToEdit = null; //clear cache + updateListView(); + } + + if(requestCode == 4000) //editRule + { + ruleToEdit = null; //clear cache + updateListView(); + } + + AutomationService service = AutomationService.getInstance(); + if(service != null) + service.applySettingsAndRules(); + + if(boundToService && AutomationService.isMyServiceRunning(this)) + { + myAutomationService.serviceInterface(serviceCommands.updateNotification); //in case names got changed. + unBindFromService(); + } + } + + private AlertDialog getRuleDialog(final Rule ruleThisIsAbout) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this); + alertDialogBuilder.setTitle(getResources().getString(R.string.whatToDoWithRule)); + alertDialogBuilder.setItems(new String[]{ getResources().getString(R.string.runManually), getResources().getString(R.string.edit), getResources().getString(R.string.deleteCapital) }, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + switch(which) + { + case 0: + if(AutomationService.isMyServiceRunning(ActivityMainRules.this)) + { + AutomationService runContext = AutomationService.getInstance(); + if(runContext != null) + { + ruleThisIsAbout.activate(runContext, true); + break; + } + } + Toast.makeText(ActivityMainRules.this, getResources().getString(R.string.serviceHasToRunForThat), Toast.LENGTH_LONG).show(); + break; + case 1: + ruleToEdit = ruleThisIsAbout; + Intent manageSpecificRuleIntent = new Intent (ActivityMainRules.this, ActivityManageSpecificRule.class); + startActivityForResult(manageSpecificRuleIntent, 4000); + break; + case 2: + if(ruleThisIsAbout.delete()) + updateListView(); + break; + } + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + + public void updateListView() + { + Miscellaneous.logEvent("i", "ListView", "Attempting to update RuleListView", 4); + try + { + if(ruleListView.getAdapter() == null) + ruleListView.setAdapter(ruleListViewAdapter); + + ruleListViewAdapter.notifyDataSetChanged(); + } + catch(NullPointerException e) + {} + + try + { + if(AutomationService.isMyServiceRunning(this)) + AlarmListener.reloadAlarms(); + } + catch(NullPointerException e) + { + // AlarmManager instance not prepared, yet. + } + } +} diff --git a/app/src/main/java/com/jens/automation2/ActivityMainScreen.java b/app/src/main/java/com/jens/automation2/ActivityMainScreen.java new file mode 100644 index 0000000..8cbe196 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivityMainScreen.java @@ -0,0 +1,600 @@ +package com.jens.automation2; + +import android.annotation.SuppressLint; +import android.app.AlertDialog; +import android.content.Context; +import android.content.DialogInterface; +import android.content.Intent; +import android.net.Uri; +import android.os.Build; +import android.os.Bundle; +import android.view.MotionEvent; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.View.OnTouchListener; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.CompoundButton; +import android.widget.CompoundButton.OnCheckedChangeListener; +import android.widget.ListView; +import android.widget.TextView; +import android.widget.Toast; +import android.widget.ToggleButton; + +import com.google.android.gms.appindexing.AppIndex; +import com.google.android.gms.appindexing.Thing; +import com.google.android.gms.common.api.GoogleApiClient; +import com.jens.automation2.AutomationService.serviceCommands; +import com.jens.automation2.Trigger.Trigger_Enum; +import com.jens.automation2.location.LocationProvider; + +import java.util.Calendar; + +@SuppressLint("NewApi") +public class ActivityMainScreen extends ActivityGeneric +{ + private static boolean guiChangeInProgress = false; + + private static ActivityMainScreen activityMainScreenInstance = null; + private ToggleButton toggleService, tbLockSound; + private Button bShowHelp, bPrivacy, bSettingsErase, bSettingsSetToDefault, bVolumeTest, bAddSoundLockTIme; + private TextView tvActivePoi, tvClosestPoi, tvLastRule, tvMainScreenNote, tvlockSoundDuration; + + private ListView lvRuleHistory; + private ArrayAdapter ruleHistoryListViewAdapter; + + private static boolean uiUpdateRunning = false; + /** + * ATTENTION: This was auto-generated to implement the App Indexing API. + * See https://g.co/AppIndexing/AndroidStudio for more information. + */ + private GoogleApiClient client; + + @Override + public void onCreate(Bundle savedInstanceState) + { + super.onCreate(savedInstanceState); + setContentView(R.layout.main_overview_layout); + + activityMainScreenInstance = this; + + if(ActivityPermissions.needMorePermissions(ActivityMainScreen.this)) + { + Intent permissionsIntent = new Intent(ActivityMainScreen.this, ActivityPermissions.class); + startActivityForResult(permissionsIntent, 7000); + } + + Settings.readFromPersistentStorage(this); + + guiChangeInProgress = true; + + tvActivePoi = (TextView) findViewById(R.id.tvActivePoi); + tvClosestPoi = (TextView) findViewById(R.id.tvClosestPoi); + lvRuleHistory = (ListView) findViewById(R.id.lvRuleHistory); + tvLastRule = (TextView) findViewById(R.id.tvTimeFrameHelpText); + tvMainScreenNote = (TextView) findViewById(R.id.tvMainScreenNote); + tvlockSoundDuration = (TextView)findViewById(R.id.tvlockSoundDuration); + tbLockSound = (ToggleButton) findViewById(R.id.tbLockSound); + toggleService = (ToggleButton) findViewById(R.id.tbArmMastListener); + toggleService.setChecked(AutomationService.isMyServiceRunning(this)); + toggleService.setOnCheckedChangeListener(new OnCheckedChangeListener() + { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) + { + if (!ActivityMainScreen.this.uiUpdateRunning) + { + if (toggleService.isChecked()) + { + startAutomationService(getBaseContext(), false); + } else + { + stopAutomationService(); + } + } + } + }); + + tvMainScreenNote.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + Intent intent = new Intent(ActivityMainScreen.this, ActivityPermissions.class); + startActivityForResult(intent, ActivityPermissions.requestCodeForPermissions); + } + }); + + tbLockSound.setOnCheckedChangeListener(new OnCheckedChangeListener() + { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) + { + Settings.lockSoundChanges = isChecked; + + if(!isChecked) + { + AutomationService.getInstance().nullLockSoundChangesEnd(); + updateMainScreen(); + } + + if (!guiChangeInProgress) + Settings.writeSettings(ActivityMainScreen.this); + } + }); + + Button bSettings = (Button) findViewById(R.id.bSettings); + bSettings.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + Intent myIntent = new Intent(ActivityMainScreen.this, ActivitySettings.class); + startActivityForResult(myIntent, 6000); + } + }); + + Button bVolumeTest = (Button) findViewById(R.id.bVolumeTest); + bVolumeTest.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + Intent intent = new Intent(ActivityMainScreen.this, ActivityVolumeTest.class); + startActivity(intent); + } + }); + + bShowHelp = (Button) findViewById(R.id.bShowHelp); + bShowHelp.setOnClickListener(new OnClickListener() + { + + @Override + public void onClick(View v) + { + Intent showHelpIntent = new Intent(ActivityMainScreen.this, ActivityHelp.class); + startActivity(showHelpIntent); + } + }); + + bPrivacy = (Button) findViewById(R.id.bPrivacy); + bPrivacy.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + AlertDialog.Builder builder = new AlertDialog.Builder(ActivityMainScreen.this); + builder.setMessage(getResources().getString(R.string.privacyConfirmationText)); + builder.setPositiveButton(getResources().getString(R.string.yes), new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + openPrivacyPolicy(); + } + }); + builder.setNegativeButton(getResources().getString(R.string.no), null); + builder.create().show(); + } + }); + + /*bSettingsErase = (Button)findViewById(R.id.bSettingsErase); + bSettingsErase.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + getEraseSettingsDialog(ActivityMainScreen.this).show(); + } + });*/ + bSettingsSetToDefault = (Button) findViewById(R.id.bSettingsSetToDefault); + bSettingsSetToDefault.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + getDefaultSettingsDialog(ActivityMainScreen.this).show(); + } + }); + + lvRuleHistory.setOnTouchListener(new OnTouchListener() + { + @Override + public boolean onTouch(View v, MotionEvent event) + { + v.getParent().requestDisallowInterceptTouchEvent(true); + return false; + } + }); + + bAddSoundLockTIme = (Button)findViewById(R.id.bAddSoundLockTIme); + bAddSoundLockTIme.setText("+" + Settings.lockSoundChangesInterval + " min"); + bAddSoundLockTIme.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View view) + { + if(AutomationService.isMyServiceRunning(ActivityMainScreen.this)) + { + AutomationService.getInstance().lockSoundChangesEndAddTime(); + ActivityMainScreen.updateMainScreen(); + } + else + Toast.makeText(ActivityMainScreen.this, getResources().getString(R.string.serviceNotRunning), Toast.LENGTH_LONG).show(); + } + }); + + ruleHistoryListViewAdapter = new ArrayAdapter(this, R.layout.text_view_for_poi_listview_mediumtextsize, Rule.getRuleRunHistory()); + + if (PointOfInterest.getPointOfInterestCollection() == null | PointOfInterest.getPointOfInterestCollection().size() == 0) + PointOfInterest.loadPoisFromFile(); + if (Rule.getRuleCollection() == null | Rule.getRuleCollection().size() == 0) + Rule.readFromFile(); + + ActivityMainScreen.updateMainScreen(); + + this.storeServiceReferenceInVariable(); + + guiChangeInProgress = false; + // ATTENTION: This was auto-generated to implement the App Indexing API. + // See https://g.co/AppIndexing/AndroidStudio for more information. + client = new GoogleApiClient.Builder(this).addApi(AppIndex.API).build(); + } + + private static AlertDialog getEraseSettingsDialog(final Context context) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(context); + alertDialogBuilder.setTitle(context.getResources().getString(R.string.areYouSure)); + alertDialogBuilder.setPositiveButton(context.getResources().getString(R.string.yes), new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + if (Settings.eraseSettings(context)) + Toast.makeText(context, context.getResources().getString(R.string.settingsErased), Toast.LENGTH_LONG).show(); + } + }); + alertDialogBuilder.setNegativeButton(context.getResources().getString(R.string.no), null); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + + private static AlertDialog getDefaultSettingsDialog(final Context context) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(context); + alertDialogBuilder.setTitle(context.getResources().getString(R.string.areYouSure)); + alertDialogBuilder.setPositiveButton(context.getResources().getString(R.string.yes), new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + if (Settings.initializeSettings(context, true)) + Toast.makeText(context, context.getResources().getString(R.string.settingsSetToDefault), Toast.LENGTH_LONG).show(); + } + }); + alertDialogBuilder.setNegativeButton(context.getResources().getString(R.string.no), null); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + + public static ActivityMainScreen getActivityMainScreenInstance() + { + return activityMainScreenInstance; + } + + public static void updateMainScreen() + { + Miscellaneous.logEvent("i", "MainScreen", "Request to update notification.", 5); + + if (activityMainScreenInstance != null) + { + if(ActivityPermissions.needMorePermissions(activityMainScreenInstance)) + { + activityMainScreenInstance.tvMainScreenNote.setText(R.string.mainScreenPermissionNote); + activityMainScreenInstance.tvMainScreenNote.setVisibility(View.VISIBLE); + } + else + { + activityMainScreenInstance.tvMainScreenNote.setText(""); + activityMainScreenInstance.tvMainScreenNote.setVisibility(View.GONE); + } + + if (AutomationService.isMyServiceRunning(activityMainScreenInstance)) + { + Miscellaneous.logEvent("i", "MainScreen", "Service is running. Updating mainscreen with this info.", 5); + uiUpdateRunning = true; + activityMainScreenInstance.toggleService.setChecked(true); + uiUpdateRunning = false; + // if(activityMainScreenInstance.hasWindowFocus()) + // { + try + { + PointOfInterest activePoi = PointOfInterest.getActivePoi(); + if (activePoi == null) + { + PointOfInterest closestPoi = PointOfInterest.getClosestPOI(LocationProvider.getInstance().getCurrentLocation()); + activityMainScreenInstance.tvActivePoi.setText("none"); + activityMainScreenInstance.tvClosestPoi.setText(closestPoi.getName()); + } + else + { + activityMainScreenInstance.tvActivePoi.setText(activePoi.getName()); + activityMainScreenInstance.tvClosestPoi.setText("n./a."); + } + } + catch (NullPointerException e) + { + if (PointOfInterest.getPointOfInterestCollection().size() > 0) + { + if( + Rule.isAnyRuleUsing(Trigger_Enum.pointOfInterest) + && + ActivityPermissions.havePermission(ActivityPermissions.permissionNameLocationCoarse, AutomationService.getInstance()) + && + ActivityPermissions.havePermission(ActivityPermissions.permissionNameLocationFine, AutomationService.getInstance()) + ) + activityMainScreenInstance.tvActivePoi.setText(activityMainScreenInstance.getResources().getString(R.string.stillGettingPosition)); + else + activityMainScreenInstance.tvActivePoi.setText(activityMainScreenInstance.getResources().getString(R.string.locationEngineNotActive)); + + activityMainScreenInstance.tvClosestPoi.setText("n./a."); + } + else + { + activityMainScreenInstance.tvActivePoi.setText(activityMainScreenInstance.getResources().getString(R.string.noPoisDefinedShort)); + activityMainScreenInstance.tvClosestPoi.setText("n./a."); + } + } + + try + { + activityMainScreenInstance.tvLastRule.setText(Rule.getLastActivatedRule().getName() + " " + activityMainScreenInstance.getResources().getString(R.string.at) + " " + Rule.getLastActivatedRuleActivationTime().toLocaleString()); + activityMainScreenInstance.updateListView(); + } + catch (Exception e) + { + activityMainScreenInstance.tvLastRule.setText("n./a."); + } + } + else + { + Miscellaneous.logEvent("i", "MainScreen", "Service not running. Updating mainscreen with this info.", 5); + activityMainScreenInstance.toggleService.setChecked(false); + activityMainScreenInstance.tvActivePoi.setText(activityMainScreenInstance.getResources().getString(R.string.serviceNotRunning)); + activityMainScreenInstance.tvClosestPoi.setText(""); + activityMainScreenInstance.tvLastRule.setText(""); + } + +// uiUpdateRunning = true; + if(AutomationService.isMyServiceRunning(ActivityMainScreen.getActivityMainScreenInstance()) && AutomationService.getInstance() != null) + { + AutomationService.getInstance().checkLockSoundChangesTimeElapsed(); + + Calendar end = AutomationService.getInstance().getLockSoundChangesEnd(); + activityMainScreenInstance.tbLockSound.setChecked(end != null); + activityMainScreenInstance.tbLockSound.setEnabled(end != null); + + if(end != null) + { + Calendar now = Calendar.getInstance(); + long millis = end.getTimeInMillis() - now.getTimeInMillis(); + long minutes = millis/1000/60; + if(minutes < 60) + activityMainScreenInstance.tvlockSoundDuration.setText(String.valueOf(minutes + " min...")); + else + { + double hours = (double)minutes / 60.0; + activityMainScreenInstance.tvlockSoundDuration.setText(String.valueOf(Math.round(hours * 100.0) / 100.0) + " h..."); + } + } + else + activityMainScreenInstance.tvlockSoundDuration.setText(String.valueOf("")); + } + else + { + activityMainScreenInstance.tbLockSound.setChecked(false); + activityMainScreenInstance.tbLockSound.setEnabled(false); + activityMainScreenInstance.tvlockSoundDuration.setText(""); + } + Settings.writeSettings(activityMainScreenInstance); +// uiUpdateRunning = false; +// } +// else +// Miscellaneous.logEvent("i", "ActivityMainScreen", "Window doesn't have focus. We're not updating anything.", 5); + } + else + Miscellaneous.logEvent("i", "ActivityMainScreen", "Activity not running. No need to update.", 5); + } + + @Override + protected void onActivityResult(int requestCode, int resultCode, Intent data) + { + super.onActivityResult(requestCode, resultCode, data); + +// Miscellaneous.logEvent("i", "ListView", "Notifying ListViewAdapter", 4); + + if (AutomationService.isMyServiceRunning(this)) + bindToService(); + + switch (requestCode) + { + case ActivityPermissions.requestCodeForPermissions: + updateMainScreen(); + break; + case 6000: //settings + Settings.readFromPersistentStorage(this); + + if (boundToService && AutomationService.isMyServiceRunning(this)) + myAutomationService.serviceInterface(serviceCommands.reloadSettings); + + if(AutomationService.isMyServiceRunning(ActivityMainScreen.this)) + Toast.makeText(this, getResources().getString(R.string.settingsWillTakeTime), Toast.LENGTH_LONG).show(); + + break; + } + + if (AutomationService.isMyServiceRunning(this)) + { + // Let service reload via binding interface. + if (boundToService) + { + myAutomationService.serviceInterface(serviceCommands.updateNotification); //in case names got changed. + unBindFromService(); + } + } + else + { + // Let service reload classically. + AutomationService service = AutomationService.getInstance(); + if (service != null) + service.applySettingsAndRules(); + } + } + + public static void startAutomationService(Context context, boolean startAtBoot) + { + try + { + if (Rule.getRuleCollection().size() > 0) + { + if (!AutomationService.isMyServiceRunning(context)) + { +// if(myServiceIntent == null) //do we need that line????? + myServiceIntent = new Intent(context, AutomationService.class); + myServiceIntent.putExtra("startAtBoot", startAtBoot); + context.startService(myServiceIntent); + } else + Miscellaneous.logEvent("w", "Service", context.getResources().getString(R.string.logServiceAlreadyRunning), 3); + } else + { + Toast.makeText(context, context.getResources().getString(R.string.serviceWontStart), Toast.LENGTH_LONG).show(); + activityMainScreenInstance.toggleService.setChecked(false); + } + } + catch (NullPointerException ne) + { + Toast.makeText(context, context.getResources().getString(R.string.serviceWontStart), Toast.LENGTH_LONG).show(); + activityMainScreenInstance.toggleService.setChecked(false); + } + catch (Exception e) + { + Toast.makeText(context, "Error: " + e.getMessage(), Toast.LENGTH_LONG).show(); + activityMainScreenInstance.toggleService.setChecked(false); + } + } + + private void stopAutomationService() + { + if (myServiceIntent == null) + myServiceIntent = new Intent(this, AutomationService.class); + stopService(myServiceIntent); + } + + @Override + protected void onRestart() + { + super.onRestart(); + toggleService.setChecked(AutomationService.isMyServiceRunning(this)); + ActivityMainScreen.updateMainScreen(); + } + + @Override + protected void onStart() + { + super.onStart();// ATTENTION: This was auto-generated to implement the App Indexing API. +// See https://g.co/AppIndexing/AndroidStudio for more information. + client.connect(); + toggleService.setChecked(AutomationService.isMyServiceRunning(this)); + ActivityMainScreen.updateMainScreen(); + // ATTENTION: This was auto-generated to implement the App Indexing API. + // See https://g.co/AppIndexing/AndroidStudio for more information. + AppIndex.AppIndexApi.start(client, getIndexApiAction()); + } + + @Override + protected void onResume() + { + super.onResume(); + toggleService.setChecked(AutomationService.isMyServiceRunning(this)); + ActivityMainScreen.updateMainScreen(); + + if(Build.VERSION.SDK_INT >= 28 && !Settings.noticeAndroid9MicrophoneShown && Rule.isAnyRuleUsing(Trigger_Enum.noiseLevel)) + { + Settings.noticeAndroid9MicrophoneShown = true; + Settings.writeSettings(ActivityMainScreen.this); + Miscellaneous.messageBox(getResources().getString(R.string.app_name), getResources().getString(R.string.android9RecordAudioNotice) + " " + getResources().getString(R.string.messageNotShownAgain), ActivityMainScreen.this).show(); + } + + if(Build.VERSION.SDK_INT >= 29 && !Settings.noticeAndroid10WifiShown && Rule.isAnyRuleUsing(Action.Action_Enum.setWifi)) + { + Settings.noticeAndroid10WifiShown = true; + Settings.writeSettings(ActivityMainScreen.this); + Miscellaneous.messageBox(getResources().getString(R.string.app_name), getResources().getString(R.string.android10WifiToggleNotice) + " " + getResources().getString(R.string.messageNotShownAgain), ActivityMainScreen.this).show(); + } + } + + @Override + protected void onDestroy() + { + super.onDestroy(); + activityMainScreenInstance = null; + } + + private void openPrivacyPolicy() + { + String privacyPolicyUrl = "http://server47.de/automation/privacy.html"; + + Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(privacyPolicyUrl)); + startActivity(browserIntent); + } + + private void updateListView() + { + Miscellaneous.logEvent("i", "ListView", "Attempting to update lvRuleHistory", 4); + try + { + if (lvRuleHistory.getAdapter() == null) + lvRuleHistory.setAdapter(ruleHistoryListViewAdapter); + + ruleHistoryListViewAdapter.notifyDataSetChanged(); + } catch (NullPointerException e) + { + } + } + + /** + * ATTENTION: This was auto-generated to implement the App Indexing API. + * See https://g.co/AppIndexing/AndroidStudio for more information. + */ + public com.google.android.gms.appindexing.Action getIndexApiAction() + { + Thing object = new Thing.Builder() + .setName("ActivityMainScreen Page") // TODO: Define a title for the content shown. + // TODO: Make sure this auto-generated URL is correct. + .setUrl(Uri.parse("http://[ENTER-YOUR-URL-HERE]")) + .build(); + return new com.google.android.gms.appindexing.Action.Builder(com.google.android.gms.appindexing.Action.TYPE_VIEW) + .setObject(object) + .setActionStatus(com.google.android.gms.appindexing.Action.STATUS_TYPE_COMPLETED) + .build(); + } + + @Override + public void onStop() + { + super.onStop(); + + // ATTENTION: This was auto-generated to implement the App Indexing API. + // See https://g.co/AppIndexing/AndroidStudio for more information. + AppIndex.AppIndexApi.end(client, getIndexApiAction()); + client.disconnect(); + } + + public static void showMessageBox(String title, String text) + { + Miscellaneous.messageBox(title, text, ActivityMainScreen.getActivityMainScreenInstance()); + } + +} \ No newline at end of file diff --git a/app/src/main/java/com/jens/automation2/ActivityMainTabLayout.java b/app/src/main/java/com/jens/automation2/ActivityMainTabLayout.java new file mode 100644 index 0000000..ff0195f --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivityMainTabLayout.java @@ -0,0 +1,70 @@ +package com.jens.automation2; + +import android.annotation.SuppressLint; +import android.app.TabActivity; +import android.content.Intent; +import android.os.Bundle; +import android.widget.TabHost; +import android.widget.TabHost.TabSpec; + +import com.jens.automation2.receivers.NfcReceiver; + + +@SuppressLint("NewApi") +public class ActivityMainTabLayout extends TabActivity +{ + + @Override + protected void onCreate(Bundle savedInstanceState) + { + super.onCreate(savedInstanceState); + setContentView(R.layout.main_tab_layout); + + TabHost tabHost = getTabHost(); + + TabSpec specOverview = tabHost.newTabSpec("overview"); + specOverview.setIndicator(getResources().getString(R.string.overview), getResources().getDrawable(R.drawable.icon_overview_tab)); + Intent overviewIntent = new Intent(this, ActivityMainScreen.class); + specOverview.setContent(overviewIntent); + + TabSpec specPoi = tabHost.newTabSpec("pois"); + specPoi.setIndicator(getResources().getString(R.string.pois), getResources().getDrawable(R.drawable.map)); + Intent mainPoiIntent = new Intent(this, ActivityMainPoi.class); + specPoi.setContent(mainPoiIntent); + + TabSpec specRules = tabHost.newTabSpec("rules"); + specRules.setIndicator(getResources().getString(R.string.rules), getResources().getDrawable(R.drawable.gear)); + Intent mainRulesIntent = new Intent(this, ActivityMainRules.class); + specRules.setContent(mainRulesIntent); + + TabSpec specProfiles = tabHost.newTabSpec("profiles"); + specProfiles.setIndicator(getResources().getString(R.string.profiles), getResources().getDrawable(R.drawable.sound)); + Intent mainProfilesIntent = new Intent(this, ActivityMainProfiles.class); + specProfiles.setContent(mainProfilesIntent); + + tabHost.addTab(specOverview); + tabHost.addTab(specPoi); + tabHost.addTab(specRules); + tabHost.addTab(specProfiles); + + tabHost.setCurrentTab(Settings.startScreen); + } + + + @Override + protected void onResume() + { + super.onResume(); +// Miscellaneous.logEvent("i", "NFC", "ActivityMainTabLayout.onResume().", 5); + NfcReceiver.checkIntentForNFC(this, getIntent()); +// NfcReceiver.checkIntentForNFC(this, new Intent(this.getApplicationContext(), this.getClass())); + } + + @Override + protected void onNewIntent(Intent intent) + { +// Miscellaneous.logEvent("i", "NFC", "ActivityMainTabLayout.onNewIntent().", 5); +// setIntent(intent); + NfcReceiver.checkIntentForNFC(this, intent); + } +} diff --git a/app/src/main/java/com/jens/automation2/ActivityManageBluetoothTrigger.java b/app/src/main/java/com/jens/automation2/ActivityManageBluetoothTrigger.java new file mode 100644 index 0000000..6f6d5dc --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivityManageBluetoothTrigger.java @@ -0,0 +1,187 @@ +package com.jens.automation2; + +import android.app.Activity; +import android.bluetooth.BluetoothDevice; +import android.os.Bundle; +import android.util.Log; +import android.view.View; +import android.view.View.OnClickListener; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.CompoundButton; +import android.widget.CompoundButton.OnCheckedChangeListener; +import android.widget.RadioButton; +import android.widget.Spinner; +import android.widget.Toast; + +import com.jens.automation2.receivers.BluetoothReceiver; + +public class ActivityManageBluetoothTrigger extends Activity +{ + protected static Trigger editedBluetoothTrigger; + RadioButton radioAnyBluetoothDevice, radioNoDevice, radioDeviceFromList, radioBluetoothConnected, radioBluetoothDisconnected, radioBluetoothInRange, radioBluetoothOutRange; + Button bSaveBluetoothTrigger; + Spinner spinnerBluetoothDevices; + + ArrayAdapter bluetoothDevicesSpinnerAdapter; + + @Override + protected void onCreate(Bundle savedInstanceState) + { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_bluetooth_trigger); + + radioAnyBluetoothDevice = (RadioButton)findViewById(R.id.radioAnyBluetoothDevice); + radioNoDevice = (RadioButton)findViewById(R.id.radioNoDevice); + radioDeviceFromList = (RadioButton)findViewById(R.id.radioDeviceFromList); + radioBluetoothConnected = (RadioButton)findViewById(R.id.radioBluetoothConnected); + radioBluetoothDisconnected = (RadioButton)findViewById(R.id.radioBluetoothDisconnected); + radioBluetoothInRange = (RadioButton)findViewById(R.id.radioBluetoothInRange); + radioBluetoothOutRange = (RadioButton)findViewById(R.id.radioBluetoothOutRange); + bSaveBluetoothTrigger = (Button)findViewById(R.id.bSaveBluetoothTrigger); + spinnerBluetoothDevices = (Spinner)findViewById(R.id.spinnerBluetoothDevices); + + bluetoothDevicesSpinnerAdapter = new ArrayAdapter(this, R.layout.text_view_for_poi_listview_mediumtextsize, BluetoothReceiver.getAllPairedBluetoothDevicesStrings()); + + radioDeviceFromList.setOnCheckedChangeListener(new OnCheckedChangeListener() + { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) + { + spinnerBluetoothDevices.setEnabled(isChecked); + } + }); + + bSaveBluetoothTrigger.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + if(saveTrigger()) + { + setResult(RESULT_OK); + finish(); + } + } + }); + + refreshBluetoothDeviceSpinner(); + spinnerBluetoothDevices.setEnabled(false); + + if(editedBluetoothTrigger.getBluetoothDeviceAddress() != null && editedBluetoothTrigger.getBluetoothDeviceAddress().length() > 0) + loadVariableIntoGui(); + } + + protected void refreshBluetoothDeviceSpinner() + { + Miscellaneous.logEvent("i", "Spinner", "Attempting to update spinnerBluetoothDevices", 4); + if(spinnerBluetoothDevices.getAdapter() == null) + { + spinnerBluetoothDevices.setAdapter(bluetoothDevicesSpinnerAdapter); + } + + bluetoothDevicesSpinnerAdapter.notifyDataSetChanged(); + } + + protected boolean saveTrigger() + { + try + { + // DEVICE + + if(radioAnyBluetoothDevice.isChecked()) + { + editedBluetoothTrigger.setBluetoothDeviceAddress(""); + } + else if(radioNoDevice.isChecked()) + { + editedBluetoothTrigger.setBluetoothDeviceAddress(""); + } + else if(radioDeviceFromList.isChecked()) + { + BluetoothDevice selectedDevice = BluetoothReceiver.getAllPairedBluetoothDevices()[spinnerBluetoothDevices.getSelectedItemPosition()]; + if(selectedDevice != null) + { + editedBluetoothTrigger.setBluetoothDeviceAddress(selectedDevice.getAddress()); + } + else + Miscellaneous.logEvent("w", "ActivityManageBluetoothTrigger", "Device not found.", 3); + } + else + { + Toast.makeText(ActivityManageBluetoothTrigger.this, getResources().getString(R.string.selectDeviceOption), Toast.LENGTH_LONG).show(); + return false; + } + + + // EVENT + + if(radioBluetoothConnected.isChecked()) + { + editedBluetoothTrigger.setTriggerParameter(true); + editedBluetoothTrigger.setBluetoothEvent(BluetoothDevice.ACTION_ACL_CONNECTED); + } + else if(radioBluetoothDisconnected.isChecked()) + { + editedBluetoothTrigger.setTriggerParameter(false); + editedBluetoothTrigger.setBluetoothEvent(BluetoothDevice.ACTION_ACL_DISCONNECTED); + } + else if(radioBluetoothInRange.isChecked()) + { + editedBluetoothTrigger.setTriggerParameter(true); + editedBluetoothTrigger.setBluetoothEvent(BluetoothDevice.ACTION_FOUND); + } + else if(radioBluetoothOutRange.isChecked()) + { + editedBluetoothTrigger.setTriggerParameter(false); + editedBluetoothTrigger.setBluetoothEvent(BluetoothDevice.ACTION_FOUND); + } + else + { + Toast.makeText(ActivityManageBluetoothTrigger.this, getResources().getString(R.string.selectConnectionOption), Toast.LENGTH_LONG).show(); + return false; + } + + return true; + } + catch(Exception e) + { + Miscellaneous.logEvent("w", "ActivityManageBluetoothTrigger", "Error during trigger create/change: " + Log.getStackTraceString(e), 2); + } + + return false; + } + + protected void loadVariableIntoGui() + { + if(editedBluetoothTrigger != null) + { + if(editedBluetoothTrigger.getBluetoothDeviceAddress().equals("")) + { + radioAnyBluetoothDevice.setChecked(true); + } + else if(editedBluetoothTrigger.getBluetoothDeviceAddress().equals("")) + { + radioNoDevice.setChecked(true); + } + else + { + radioDeviceFromList.setChecked(true); + spinnerBluetoothDevices.setSelection(BluetoothReceiver.getDevicePositionByAddress(editedBluetoothTrigger.getBluetoothDeviceAddress())); + } + + if(editedBluetoothTrigger.getBluetoothEvent().equals(BluetoothDevice.ACTION_ACL_CONNECTED)) + { + radioBluetoothConnected.setChecked(true); + } + else if(editedBluetoothTrigger.getBluetoothEvent().equals(BluetoothDevice.ACTION_ACL_DISCONNECTED)) + { + radioBluetoothDisconnected.setChecked(true); + } + else + { + radioBluetoothInRange.setChecked(true); + } + } + } +} diff --git a/app/src/main/java/com/jens/automation2/ActivityManageBrightnessSetting.java b/app/src/main/java/com/jens/automation2/ActivityManageBrightnessSetting.java new file mode 100644 index 0000000..fc79853 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivityManageBrightnessSetting.java @@ -0,0 +1,64 @@ +package com.jens.automation2; + +import android.app.Activity; +import android.content.Intent; +import android.os.Bundle; +import android.view.View; +import android.widget.Button; +import android.widget.CheckBox; +import android.widget.CompoundButton; +import android.widget.SeekBar; +import android.widget.TextView; + +import androidx.annotation.Nullable; + +public class ActivityManageBrightnessSetting extends Activity +{ + CheckBox chkAutoBrightness; + SeekBar sbBrightness; + Button bApplyBrightness; + TextView tvAutoBrightnessNotice; + + @Override + protected void onCreate(@Nullable Bundle savedInstanceState) + { + setContentView(R.layout.activity_manage_brightness_setting); + super.onCreate(savedInstanceState); + + chkAutoBrightness = (CheckBox)findViewById(R.id.chkAutoBrightness); + sbBrightness = (SeekBar)findViewById(R.id.sbBrightness); + bApplyBrightness = (Button)findViewById(R.id.bApplyBrightness); + tvAutoBrightnessNotice = (TextView)findViewById(R.id.tvAutoBrightnessNotice); + + Intent input = getIntent(); + + if(input.hasExtra("autoBrightness")) + chkAutoBrightness.setChecked(input.getBooleanExtra("autoBrightness", false)); + + if(input.hasExtra("brightnessValue")) + sbBrightness.setProgress(input.getIntExtra("brightnessValue", 0)); + + bApplyBrightness.setOnClickListener(new View.OnClickListener() + { + @Override + public void onClick(View view) + { + Intent answer = new Intent(); + answer.putExtra("autoBrightness", chkAutoBrightness.isChecked()); + answer.putExtra("brightnessValue", sbBrightness.getProgress()); + setResult(RESULT_OK, answer); + finish(); + } + }); + + chkAutoBrightness.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() + { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) + { + if(isChecked) + tvAutoBrightnessNotice.setText(R.string.autoBrightnessNotice); + } + }); + } +} diff --git a/app/src/main/java/com/jens/automation2/ActivityManageNfc.java b/app/src/main/java/com/jens/automation2/ActivityManageNfc.java new file mode 100644 index 0000000..59fe242 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivityManageNfc.java @@ -0,0 +1,306 @@ +package com.jens.automation2; + +import android.annotation.SuppressLint; +import android.app.Activity; +import android.app.PendingIntent; +import android.app.ProgressDialog; +import android.content.DialogInterface; +import android.content.DialogInterface.OnCancelListener; +import android.content.Intent; +import android.content.IntentFilter; +import android.nfc.NfcAdapter; +import android.nfc.Tag; +import android.os.Bundle; +import android.view.View; +import android.view.View.OnClickListener; +import android.widget.Button; +import android.widget.EditText; +import android.widget.TextView; +import android.widget.Toast; + +import com.jens.automation2.receivers.NfcReceiver; + +@SuppressLint("NewApi") +public class ActivityManageNfc extends Activity +{ + public static String generatedId = null; + private static Tag discoveredTag = null; + + EditText etNewNfcIdValue; + Button bReadNfcTag, bUseValueCurrentlyStored, bWriteNfcTag; + TextView tvCurrentNfcId; + + private static int currentStatus = 0; + private static ProgressDialog progressDialog = null; + + // Check if NFC is activated + + @Override + protected void onCreate(Bundle savedInstanceState) + { + super.onCreate(savedInstanceState); + setContentView(R.layout.manage_nfc); + + etNewNfcIdValue = (EditText)findViewById(R.id.etNewNfcIdValue); + bReadNfcTag = (Button)findViewById(R.id.bReadNfcTag); + bUseValueCurrentlyStored = (Button)findViewById(R.id.bUseValueCurrentlyStored); + bWriteNfcTag = (Button)findViewById(R.id.bWriteNfcTag); + tvCurrentNfcId = (TextView)findViewById(R.id.tvCurrentNfcId); + + bReadNfcTag.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + if(discoveredTag != null) + { + generatedId = NfcReceiver.readTag(discoveredTag); + tvCurrentNfcId.setText(generatedId); + } + else + { + progressDialog = ProgressDialog.show(ActivityManageNfc.this, null, getResources().getString(R.string.nfcBringTagIntoRange), false, true, new OnCancelListener() + { + @Override + public void onCancel(DialogInterface dialog) + { + progressDialog.dismiss(); + progressDialog = null; + currentStatus = 0; + } + }); + } + } + }); + + bUseValueCurrentlyStored.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + if(discoveredTag != null) + { + if(checkEnteredText(false)) + { + setResult(RESULT_OK); + finish(); + } + } + else + { + progressDialog = ProgressDialog.show(ActivityManageNfc.this, null, getResources().getString(R.string.nfcBringTagIntoRange), false, true, new OnCancelListener() + { + @Override + public void onCancel(DialogInterface dialog) + { + progressDialog.dismiss(); + progressDialog = null; + currentStatus = 0; + } + }); + + currentStatus = 1; + } + } + }); + + bWriteNfcTag.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + if(checkEnteredText(true)) + { +// ActivityPermissions.requestSpecificPermission("android.permission.NFC"); + if(discoveredTag != null) + { + tryWrite(); + } + else + { + progressDialog = ProgressDialog.show(ActivityManageNfc.this, null, getResources().getString(R.string.nfcBringTagIntoRange), false, true, new OnCancelListener() + { + @Override + public void onCancel(DialogInterface dialog) + { + progressDialog.dismiss(); + progressDialog = null; + currentStatus = 0; + } + }); + + currentStatus = 2; + +// Toast.makeText(ActivityManageNfc.this, "No tag.", Toast.LENGTH_LONG).show(); +// Miscellaneous.logEvent("w", "NFC", "No tag.", 2); + } + } + } + }); + + if(generatedId != null) + etNewNfcIdValue.setText(generatedId); + } + + public static void enableForegroundDispatch(final Activity activity) + { + NfcAdapter nfcAdapter = NfcReceiver.getNfcAdapter(activity); + + final Intent intent = new Intent(activity.getApplicationContext(), activity.getClass()); + intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP); + + final PendingIntent pendingIntent = PendingIntent.getActivity(activity.getApplicationContext(), 0, intent, 0); + + IntentFilter[] filters = new IntentFilter[1]; + String[][] techList = new String[][]{}; + + // Notice that this is the same filter as in our manifest. + filters[0] = new IntentFilter(); + filters[0].addAction(NfcAdapter.ACTION_NDEF_DISCOVERED); + filters[0].addAction(NfcAdapter.ACTION_TAG_DISCOVERED); + filters[0].addAction(NfcAdapter.ACTION_TECH_DISCOVERED); + filters[0].addCategory(Intent.CATEGORY_DEFAULT); +// try +// { +// filters[0].addDataType(NfcReceiver.MIME_TEXT_PLAIN); +// } +// catch (MalformedMimeTypeException e) +// { +// throw new RuntimeException("Check your mime type."); +// } + + nfcAdapter.enableForegroundDispatch(activity, pendingIntent, filters, techList); + + Miscellaneous.logEvent("i", "NFC", "Enabled foreground dispatch.", 5); + } + + public static void disableForegroundDispatch(final Activity activity) + { + NfcAdapter nfcAdapter = NfcReceiver.getNfcAdapter(activity); + nfcAdapter.disableForegroundDispatch(activity); + Miscellaneous.logEvent("i", "NFC", "Disabled foreground dispatch.", 5); + } + + @Override + protected void onPause() + { + /** + * Call this before onPause, otherwise an IllegalArgumentException is thrown as well. + */ + disableForegroundDispatch(this); + + super.onPause(); + } + + @Override + protected void onResume() + { + super.onResume(); + /** + * It's important, that the activity is in the foreground (resumed). Otherwise + * an IllegalStateException is thrown. + */ + enableForegroundDispatch(this); + +// NfcReceiver.checkIntentForNFC(this, new Intent(this.getApplicationContext(), this.getClass())); + } + + @Override + protected void onNewIntent(Intent intent) + { + Miscellaneous.logEvent("i", "NFC", "ActivityManageNfc->onNewIntent().", 5); + + Tag tag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG); + + if(tag == null) + { + tvCurrentNfcId.setText(getResources().getString(R.string.nfcNoTag)); + } + else + { + Miscellaneous.logEvent("i", "NFC", getResources().getString(R.string.nfcTagDiscovered), 4); + Toast.makeText(this, getResources().getString(R.string.nfcTagDiscovered), Toast.LENGTH_LONG).show(); + discoveredTag = tag; + if(progressDialog != null) + { + progressDialog.dismiss(); + progressDialog = null; + } + + if(currentStatus == 0) + { + generatedId = NfcReceiver.readTag(discoveredTag); + if(generatedId != null && generatedId.length() > 0) + tvCurrentNfcId.setText(generatedId); + else + tvCurrentNfcId.setText(getResources().getString(R.string.nfcTagDataNotUsable)); + } + else if(currentStatus == 1) + { + tryRead(); + } + else if(currentStatus == 2) + if(checkEnteredText(true)) + tryWrite(); + } + +// NfcReceiver.checkIntentForNFC(this, intent); + } + + private boolean checkEnteredText(boolean checkGuiValue) + { + if(checkGuiValue) + generatedId = etNewNfcIdValue.getText().toString(); + + if(generatedId.length() == 0) + { + generatedId = null; + Toast.makeText(ActivityManageNfc.this, getResources().getString(R.string.nfcEnterValidIdentifier), Toast.LENGTH_LONG).show(); + return false; + } + else + return true; + } + + private void tryWrite() + { + if(NfcReceiver.writeTag(generatedId, discoveredTag)) + { + currentStatus = 0; + Toast.makeText(ActivityManageNfc.this, getResources().getString(R.string.nfcTagWrittenSuccessfully), Toast.LENGTH_LONG).show(); + setResult(RESULT_OK); + finish(); + } + else + { + currentStatus = 0; + Toast.makeText(ActivityManageNfc.this, getResources().getString(R.string.nfcTagWriteError), Toast.LENGTH_LONG).show(); + Miscellaneous.logEvent("e", "NFC", getResources().getString(R.string.nfcTagWriteError), 2); + } + } + + private void tryRead() + { + generatedId = NfcReceiver.readTag(discoveredTag); + if(checkEnteredText(false)) + { + currentStatus = 0; + Toast.makeText(ActivityManageNfc.this, getResources().getString(R.string.nfcTagReadSuccessfully), Toast.LENGTH_LONG).show(); + setResult(RESULT_OK); + finish(); + } + else + { + currentStatus = 0; + Toast.makeText(ActivityManageNfc.this, getResources().getString(R.string.nfcValueNotSuitable), Toast.LENGTH_LONG).show(); + generatedId = null; + } + } + + @Override + protected void onDestroy() + { + super.onDestroy(); + discoveredTag = null; + } +} \ No newline at end of file diff --git a/app/src/main/java/com/jens/automation2/ActivityManageSpecificPoi.java b/app/src/main/java/com/jens/automation2/ActivityManageSpecificPoi.java new file mode 100644 index 0000000..b1b35fe --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivityManageSpecificPoi.java @@ -0,0 +1,476 @@ +package com.jens.automation2; + +import android.app.Activity; +import android.app.AlertDialog; +import android.app.ProgressDialog; +import android.content.ActivityNotFoundException; +import android.content.Context; +import android.content.DialogInterface; +import android.content.Intent; +import android.location.Criteria; +import android.location.Location; +import android.location.LocationListener; +import android.location.LocationManager; +import android.net.Uri; +import android.os.Bundle; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.inputmethod.InputMethodManager; +import android.widget.Button; +import android.widget.EditText; +import android.widget.ImageButton; +import android.widget.Toast; + +public class ActivityManageSpecificPoi extends Activity +{ + public LocationManager myLocationManager; + MyLocationListenerGps myLocationListenerGps = new MyLocationListenerGps(); + Location locationGps = null, locationNetwork = null; +// Location locationWifi = null; + MyLocationListenerNetwork myLocationListenerNetwork = new MyLocationListenerNetwork(); + Button bGetPosition, bSavePoi; + ImageButton ibShowOnMap; + EditText guiPoiName, guiPoiLatitude, guiPoiLongitude, guiPoiRadius; + + private static ProgressDialog progressDialog; + + @Override + protected void onPause() + { + super.onPause(); + Miscellaneous.logEvent("i", "ActivityManageSpecificPoi", getResources().getString(R.string.logClearingBothLocationListeners) , 5); + myLocationManager.removeUpdates(myLocationListenerGps); + myLocationManager.removeUpdates(myLocationListenerNetwork); + } + + @Override + protected void onCreate(Bundle savedInstanceState) + { + super.onCreate(savedInstanceState); + this.setContentView(R.layout.manage_specific_poi); + + myLocationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE); + bGetPosition = (Button)findViewById(R.id.bGetPosition); + ibShowOnMap = (ImageButton)findViewById(R.id.ibShowOnMap); + + guiPoiName = (EditText)findViewById(R.id.etPoiName); + guiPoiLatitude = (EditText)findViewById(R.id.etPoiLatitude); + guiPoiLongitude = (EditText)findViewById(R.id.etPoiLongitude); + guiPoiRadius = (EditText)findViewById(R.id.etPoiRadius); + + bGetPosition.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + hideKeyboard(); + getNotificationDialog(getResources().getString(R.string.positioningWindowNotice)).show(); + } + }); + + bSavePoi = (Button)findViewById(R.id.bSavePoi); + bSavePoi.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + hideKeyboard(); + + if(ActivityMainPoi.poiToEdit == null) + createPoi(); + else + changePoi(); + } + }); + + ibShowOnMap.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + hideKeyboard(); + showOnMap(); + } + }); + + if(ActivityMainPoi.poiToEdit != null) + editPoi(ActivityMainPoi.poiToEdit); + //else + // new Poi to be created + } + + private void createPoi() + { + myLocationManager.removeUpdates(myLocationListenerGps); + ActivityMainPoi.poiToEdit = new PointOfInterest(); + ActivityMainPoi.poiToEdit.setLocation(new Location("POINT_LOCATION")); + if(loadFormValuesToVariable()) + if(ActivityMainPoi.poiToEdit.create(this)) + { + this.setResult(RESULT_OK); + finish(); + } + } + private void changePoi() + { + myLocationManager.removeUpdates(myLocationListenerGps); + if(loadFormValuesToVariable()) + if(ActivityMainPoi.poiToEdit.change(this)) + { + this.setResult(RESULT_OK); + finish(); + } + } + + private void getLocation() + { + Criteria critNetwork = new Criteria(); + critNetwork.setPowerRequirement(Criteria.POWER_LOW); + critNetwork.setAltitudeRequired(false); + critNetwork.setSpeedRequired(false); + critNetwork.setBearingRequired(false); + critNetwork.setCostAllowed(false); + critNetwork.setAccuracy(Criteria.ACCURACY_COARSE); + + Criteria critGps = new Criteria(); + critGps.setAltitudeRequired(false); + critGps.setSpeedRequired(false); + critGps.setBearingRequired(false); + critGps.setCostAllowed(true); + critGps.setAccuracy(Criteria.ACCURACY_FINE); + + String provider1 = myLocationManager.getBestProvider(critNetwork, true); + String provider2 = myLocationManager.getBestProvider(critGps, true); +// String provider3 = myLocationManager.getProvider("wifi"); + + if(provider1 == null | provider2 == null) + { + Toast.makeText(this, getResources().getString(R.string.logNoSuitableProvider), Toast.LENGTH_LONG).show(); + return; + } + else + { + Miscellaneous.logEvent("i", "POI Manager", getResources().getString(R.string.logGettingPositionWithProvider) + " " + provider1, 3); + myLocationManager.requestLocationUpdates(provider1, 500, Settings.satisfactoryAccuracyNetwork, myLocationListenerNetwork); + + Miscellaneous.logEvent("i", "POI Manager", getResources().getString(R.string.logGettingPositionWithProvider) + " " + provider2, 3); + myLocationManager.requestLocationUpdates(provider2, 500, Settings.satisfactoryAccuracyGps, myLocationListenerGps); + } + + } + + private void compareLocations() + { + if(locationGps != null) + { + guiPoiLatitude.setText(String.valueOf(locationGps.getLatitude())); + guiPoiLongitude.setText(String.valueOf(locationGps.getLongitude())); + + if(locationNetwork != null) + { + Miscellaneous.logEvent("i", "POI Manager", getResources().getString(R.string.comparing), 4); + + double variance = locationGps.distanceTo(locationNetwork); + + String text = getResources().getString(R.string.distanceBetween) + " " + String.valueOf(Math.round(variance)) + " " + getResources().getString(R.string.radiusSuggestion); +// Toast.makeText(getBaseContext(), text, Toast.LENGTH_LONG).show(); + Miscellaneous.logEvent("i", "POI Manager", text, 4); +// if(variance > 50 && guiPoiRadius.getText().toString().length()>0 && Integer.parseInt(guiPoiRadius.getText().toString()) soundModeAdapter; + + public void setIncomingCallsRingtone(File incomingCallsRingtone) + { + this.incomingCallsRingtone = incomingCallsRingtone; + + if(incomingCallsRingtone != null) + tvIncomingCallsRingtone.setText(this.incomingCallsRingtone.getAbsolutePath()); + else + tvIncomingCallsRingtone.setText(getResources().getString(R.string.none)); + } + + public File getIncomingCallsRingtone() + { + return incomingCallsRingtone; + } + + public void setNotificationsRingtone(File notificationsRingtone) + { + this.notificationsRingtone = notificationsRingtone; + + if(this.notificationsRingtone != null) + tvNotificationsRingtone.setText(this.notificationsRingtone.getAbsolutePath()); + else + tvNotificationsRingtone.setText(getResources().getString(R.string.none)); + } + + public File getNotificationsRingtone() + { + return notificationsRingtone; + } + + @Override + protected void onCreate(Bundle savedInstanceState) + { + super.onCreate(savedInstanceState); + this.setContentView(R.layout.manage_specific_profile); + + checkBoxChangeSoundMode = (CheckBox)findViewById(R.id.checkBoxChangeSoundMode); + checkBoxChangeVolumeMusicVideoGameMedia = (CheckBox)findViewById(R.id.checkBoxChangeVolumeMusicVideoGameMedia); + checkBoxChangeVolumeNotifications = (CheckBox)findViewById(R.id.checkBoxChangeVolumeNotifications); + checkBoxChangeVolumeAlarms = (CheckBox)findViewById(R.id.checkBoxChangeVolumeAlarms); + checkBoxChangeIncomingCallsRingtone = (CheckBox)findViewById(R.id.checkBoxChangeIncomingCallsRingtone); + checkBoxChangeNotificationRingtone = (CheckBox)findViewById(R.id.checkBoxChangeNotificationRingtone); + checkBoxChangeAudibleSelection = (CheckBox)findViewById(R.id.checkBoxChangeAudibleSelection); + checkBoxChangeScreenLockUnlockSound = (CheckBox)findViewById(R.id.checkBoxChangeScreenLockUnlockSound); + checkBoxChangeHapticFeedback = (CheckBox)findViewById(R.id.checkBoxChangeHapticFeedback); + checkBoxChangeVibrateWhenRinging = (CheckBox)findViewById(R.id.checkBoxChangeVibrateWhenRinging); + checkBoxAudibleSelection = (CheckBox)findViewById(R.id.checkBoxAudibleSelection); + checkBoxScreenLockUnlockSound = (CheckBox)findViewById(R.id.checkBoxScreenLockUnlockSound); + checkBoxHapticFeedback = (CheckBox)findViewById(R.id.checkBoxHapticFeedback); + checkBoxVibrateWhenRinging = (CheckBox)findViewById(R.id.checkBoxVibrateWhenRinging); + spinnerSoundMode = (Spinner)findViewById(R.id.spinnerSoundMode); + seekBarVolumeMusic = (SeekBar)findViewById(R.id.seekBarVolumeMusic); + seekBarVolumeNotifications = (SeekBar)findViewById(R.id.seekBarVolumeNotifications); + seekBarVolumeAlarms = (SeekBar)findViewById(R.id.seekBarVolumeAlarms); + bChangeSoundIncomingCalls = (Button)findViewById(R.id.bChangeSoundIncomingCalls); + bChangeSoundNotifications = (Button)findViewById(R.id.bChangeSoundNotifications); + tvIncomingCallsRingtone = (TextView)findViewById(R.id.tvIncomingCallsRingtone); + tvNotificationsRingtone = (TextView)findViewById(R.id.tvNotificationsRingtone); + bSaveProfile = (Button)findViewById(R.id.bSaveProfile); + etName = (EditText)findViewById(R.id.etName); + + checkBoxVibrateWhenRinging.setEnabled(false); + checkBoxAudibleSelection.setEnabled(false); + checkBoxScreenLockUnlockSound.setEnabled(false); + checkBoxHapticFeedback.setEnabled(false); + spinnerSoundMode.setEnabled(false); + seekBarVolumeMusic.setEnabled(false); + seekBarVolumeNotifications.setEnabled(false); + seekBarVolumeAlarms.setEnabled(false); + bChangeSoundIncomingCalls.setEnabled(false); + bChangeSoundNotifications.setEnabled(false); + + spinnerSoundMode.setSelection(0); + + // Scale SeekBars to the system's maximum volume values + AudioManager am = (AudioManager) Miscellaneous.getAnyContext().getSystemService(Context.AUDIO_SERVICE); + seekBarVolumeMusic.setMax(am.getStreamMaxVolume(AudioManager.STREAM_MUSIC)); + seekBarVolumeNotifications.setMax(am.getStreamMaxVolume(AudioManager.STREAM_NOTIFICATION)); + seekBarVolumeAlarms.setMax(am.getStreamMaxVolume(AudioManager.STREAM_ALARM)); + + soundModeAdapter = new ArrayAdapter(this, R.layout.text_view_for_poi_listview_mediumtextsize, new String[] { getResources().getString(R.string.soundModeSilent), getResources().getString(R.string.soundModeVibrate), getResources().getString(R.string.soundModeNormal) }); + spinnerSoundMode.setAdapter(soundModeAdapter); + + checkBoxChangeSoundMode.setOnCheckedChangeListener(new OnCheckedChangeListener() + { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) + { + spinnerSoundMode.setEnabled(isChecked); + } + }); + checkBoxChangeVolumeMusicVideoGameMedia.setOnCheckedChangeListener(new OnCheckedChangeListener() + { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) + { + seekBarVolumeMusic.setEnabled(isChecked); + } + }); + checkBoxChangeVolumeNotifications.setOnCheckedChangeListener(new OnCheckedChangeListener() + { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) + { + seekBarVolumeNotifications.setEnabled(isChecked); + } + }); + checkBoxChangeVolumeAlarms.setOnCheckedChangeListener(new OnCheckedChangeListener() + { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) + { + seekBarVolumeAlarms.setEnabled(isChecked); + } + }); + checkBoxChangeIncomingCallsRingtone.setOnCheckedChangeListener(new OnCheckedChangeListener() + { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) + { + bChangeSoundIncomingCalls.setEnabled(isChecked); + } + }); + checkBoxChangeNotificationRingtone.setOnCheckedChangeListener(new OnCheckedChangeListener() + { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) + { + bChangeSoundNotifications.setEnabled(isChecked); + } + }); + checkBoxChangeAudibleSelection.setOnCheckedChangeListener(new OnCheckedChangeListener() + { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) + { + checkBoxAudibleSelection.setEnabled(isChecked); + } + }); + checkBoxChangeScreenLockUnlockSound.setOnCheckedChangeListener(new OnCheckedChangeListener() + { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) + { + checkBoxScreenLockUnlockSound.setEnabled(isChecked); + + if(isChecked && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) + Miscellaneous.messageBox("Info", getResources().getString(R.string.screenLockSoundNotice), ActivityManageSpecificProfile.this).show(); + } + }); + checkBoxChangeHapticFeedback.setOnCheckedChangeListener(new OnCheckedChangeListener() + { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) + { + checkBoxHapticFeedback.setEnabled(isChecked); + } + }); + checkBoxChangeVibrateWhenRinging.setOnCheckedChangeListener(new OnCheckedChangeListener() + { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) + { + checkBoxVibrateWhenRinging.setEnabled(isChecked); + } + }); + + bSaveProfile.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + try + { + if(ActivityMainProfiles.profileToEdit == null) + createProfile(ActivityManageSpecificProfile.this); + else + changeProfile(); + } + catch(Exception ex) + { + Toast.makeText(ActivityManageSpecificProfile.this, getResources().getString(R.string.errorWritingFile) + " " + ex.getMessage(), Toast.LENGTH_LONG).show(); + } + } + }); + + bChangeSoundIncomingCalls.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + try + { + Intent fileIntent = new Intent(Intent.ACTION_GET_CONTENT); + fileIntent.setType("audio/*"); + startActivityForResult(Intent.createChooser(fileIntent, "Select a ringtone"), intentCodeRingtonePickerCallsFile); + } + catch(ActivityNotFoundException e) + { + // Use media browser instead + Intent fileSelectionIntent = new Intent(RingtoneManager.ACTION_RINGTONE_PICKER); + + if(ActivityMainProfiles.profileToEdit != null) + { + Uri currenturi = Uri.parse(ActivityMainProfiles.profileToEdit.incomingCallsRingtone.getAbsolutePath()); + if(ActivityMainProfiles.profileToEdit.changeIncomingCallsRingtone) + fileSelectionIntent.putExtra(RingtoneManager.EXTRA_RINGTONE_EXISTING_URI, currenturi); + } + + startActivityForResult(fileSelectionIntent, intentCodeRingtonePickerCallsRingtone); + } + } + }); + bChangeSoundNotifications.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + try + { + Intent fileIntent = new Intent(Intent.ACTION_GET_CONTENT); + fileIntent.setType("audio/*"); + startActivityForResult(Intent.createChooser(fileIntent, "Select a ringtone"), intentCodeRingtonePickerNotificationsFile); + } + catch(ActivityNotFoundException e) + { + // Use media browser instead + Intent fileSelectionIntent = new Intent(RingtoneManager.ACTION_RINGTONE_PICKER); + + if(ActivityMainProfiles.profileToEdit != null) + { + Uri currenturi = Uri.parse(ActivityMainProfiles.profileToEdit.notificationRingtone.getAbsolutePath()); + if(ActivityMainProfiles.profileToEdit.changeNotificationRingtone) + fileSelectionIntent.putExtra(RingtoneManager.EXTRA_RINGTONE_EXISTING_URI, currenturi); + } + + startActivityForResult(fileSelectionIntent, intentCodeRingtonePickerNotificationsRingtone); + } + } + }); + + if(ActivityMainProfiles.profileToEdit != null) + editProfile(ActivityMainProfiles.profileToEdit); + //else + // new Profile to be created + +// Toast.makeText(this, getResources().getString(R.string.someOptionsNotAvailableYet), Toast.LENGTH_LONG).show(); + } + + private void createProfile(Context context) + { + if(plausibilityCheck()) + { + if(loadFormValuesToVariable()) + if(ActivityMainProfiles.profileToEdit.create(context, true)) + { + this.setResult(RESULT_OK); + finish(); + } + } + } + private void changeProfile() + { + if(plausibilityCheck()) + { + loadFormValuesToVariable(); + + if(ActivityMainProfiles.profileToEdit.change(this)) + { + this.setResult(RESULT_OK); + finish(); + } + } + } + + public void editProfile(Profile profileToEdit) + { + etName.setText(ActivityMainProfiles.profileToEdit.getName()); + checkBoxChangeSoundMode.setChecked(ActivityMainProfiles.profileToEdit.getChangeSoundMode()); + checkBoxChangeVolumeMusicVideoGameMedia.setChecked(ActivityMainProfiles.profileToEdit.getChangeVolumeMusicVideoGameMedia()); + checkBoxChangeVolumeNotifications.setChecked(ActivityMainProfiles.profileToEdit.getChangeVolumeNotifications()); + checkBoxChangeVolumeAlarms.setChecked(ActivityMainProfiles.profileToEdit.getChangeVolumeAlarms()); + checkBoxChangeIncomingCallsRingtone.setChecked(ActivityMainProfiles.profileToEdit.getChangeIncomingCallsRingtone()); + checkBoxChangeNotificationRingtone.setChecked(ActivityMainProfiles.profileToEdit.getChangeNotificationRingtone()); + checkBoxChangeAudibleSelection.setChecked(ActivityMainProfiles.profileToEdit.getChangeAudibleSelection()); + checkBoxChangeScreenLockUnlockSound.setChecked(ActivityMainProfiles.profileToEdit.getChangeScreenLockUnlockSound()); + checkBoxChangeHapticFeedback.setChecked(ActivityMainProfiles.profileToEdit.getChangeHapticFeedback()); + checkBoxChangeVibrateWhenRinging.setChecked(ActivityMainProfiles.profileToEdit.getChangeVibrateWhenRinging()); + + spinnerSoundMode.setSelection(ActivityMainProfiles.profileToEdit.getSoundMode()); + seekBarVolumeMusic.setProgress(ActivityMainProfiles.profileToEdit.getVolumeMusic()); + seekBarVolumeNotifications.setProgress(ActivityMainProfiles.profileToEdit.getVolumeNotifications()); + seekBarVolumeAlarms.setProgress(ActivityMainProfiles.profileToEdit.getVolumeAlarms()); + checkBoxAudibleSelection.setChecked(ActivityMainProfiles.profileToEdit.audibleSelection); + checkBoxScreenLockUnlockSound.setChecked(ActivityMainProfiles.profileToEdit.screenLockUnlockSound); + checkBoxHapticFeedback.setChecked(ActivityMainProfiles.profileToEdit.hapticFeedback); + checkBoxVibrateWhenRinging.setChecked(ActivityMainProfiles.profileToEdit.vibrateWhenRinging); + + setIncomingCallsRingtone(ActivityMainProfiles.profileToEdit.getIncomingCallsRingtone()); + setNotificationsRingtone(ActivityMainProfiles.profileToEdit.getNotificationRingtone()); + } + + private boolean loadFormValuesToVariable() + { + if(plausibilityCheck()) + { + if(ActivityMainProfiles.profileToEdit == null) + ActivityMainProfiles.profileToEdit = new Profile(); + + ActivityMainProfiles.profileToEdit.setName(etName.getText().toString()); + ActivityMainProfiles.profileToEdit.setChangeSoundMode(checkBoxChangeSoundMode.isChecked()); + ActivityMainProfiles.profileToEdit.setChangeVolumeMusicVideoGameMedia(checkBoxChangeVolumeMusicVideoGameMedia.isChecked()); + ActivityMainProfiles.profileToEdit.setChangeVolumeNotifications(checkBoxChangeVolumeNotifications.isChecked()); + ActivityMainProfiles.profileToEdit.setChangeVolumeAlarms(checkBoxChangeVolumeAlarms.isChecked()); + ActivityMainProfiles.profileToEdit.setChangeIncomingCallsRingtone(checkBoxChangeIncomingCallsRingtone.isChecked()); + ActivityMainProfiles.profileToEdit.setChangeNotificationRingtone(checkBoxChangeNotificationRingtone.isChecked()); + ActivityMainProfiles.profileToEdit.setChangeAudibleSelection(checkBoxChangeAudibleSelection.isChecked()); + ActivityMainProfiles.profileToEdit.setChangeScreenLockUnlockSound(checkBoxChangeScreenLockUnlockSound.isChecked()); + ActivityMainProfiles.profileToEdit.setChangeHapticFeedback(checkBoxChangeHapticFeedback.isChecked()); + ActivityMainProfiles.profileToEdit.setChangeVibrateWhenRinging(checkBoxChangeVibrateWhenRinging.isChecked()); + + ActivityMainProfiles.profileToEdit.setAudibleSelection(checkBoxAudibleSelection.isChecked()); + ActivityMainProfiles.profileToEdit.setScreenLockUnlockSound(checkBoxScreenLockUnlockSound.isChecked()); + ActivityMainProfiles.profileToEdit.setHapticFeedback(checkBoxHapticFeedback.isChecked()); + ActivityMainProfiles.profileToEdit.setVibrateWhenRinging(checkBoxVibrateWhenRinging.isChecked()); + ActivityMainProfiles.profileToEdit.setSoundMode(spinnerSoundMode.getSelectedItemPosition()); + ActivityMainProfiles.profileToEdit.setVolumeMusic(seekBarVolumeMusic.getProgress()); + ActivityMainProfiles.profileToEdit.setVolumeNotifications(seekBarVolumeNotifications.getProgress()); + ActivityMainProfiles.profileToEdit.setVolumeAlarms(seekBarVolumeAlarms.getProgress()); + ActivityMainProfiles.profileToEdit.setIncomingCallsRingtone(incomingCallsRingtone); + ActivityMainProfiles.profileToEdit.setNotificationRingtone(notificationsRingtone); + + return true; + } + + return false; + } + + private boolean plausibilityCheck() + { + if(etName.getText().toString().length() > 0) + { +// Check for duplicates +// for(Profile.) +// if(etName.getText().toString() + } + else + { + Toast.makeText(this, getResources().getString(R.string.enterAname), Toast.LENGTH_LONG).show(); + return false; + } + + if(!checkBoxChangeSoundMode.isChecked() + & + !checkBoxChangeVolumeMusicVideoGameMedia.isChecked() + & + !checkBoxChangeVolumeNotifications.isChecked() + & + !checkBoxChangeVolumeAlarms.isChecked() + & + !checkBoxChangeIncomingCallsRingtone.isChecked() + & + !checkBoxChangeNotificationRingtone.isChecked() + & + !checkBoxChangeAudibleSelection.isChecked() + & + !checkBoxChangeScreenLockUnlockSound.isChecked() + & + !checkBoxChangeHapticFeedback.isChecked() + ) + { + Toast.makeText(this, getResources().getString(R.string.noChangeSelectedProfileDoesntMakeSense), Toast.LENGTH_LONG).show(); + return false; + } + + return true; + } + + @RequiresApi(api = Build.VERSION_CODES.KITKAT) + @Override + protected void onActivityResult(int requestCode, int resultCode, Intent data) + { + if(resultCode == RESULT_OK) + { + switch (requestCode) + { + case intentCodeRingtonePickerCallsRingtone: // incoming calls + { + // Method for ringtone selection + Uri uri = data.getParcelableExtra(RingtoneManager.EXTRA_RINGTONE_PICKED_URI); + if (uri != null) + { + String ringTonePath = CompensateCrappyAndroidPaths.getPath(ActivityManageSpecificProfile.this, uri); + setIncomingCallsRingtone(new File(ringTonePath)); + } + break; + } + case intentCodeRingtonePickerCallsFile: + { + String ringTonePath = CompensateCrappyAndroidPaths.getPath(ActivityManageSpecificProfile.this, data.getData()); + setIncomingCallsRingtone(new File(ringTonePath)); + break; + } + case intentCodeRingtonePickerNotificationsRingtone: // notifications + { + Uri uri = data.getParcelableExtra(RingtoneManager.EXTRA_RINGTONE_PICKED_URI); + if (uri != null) + { + String ringTonePath = CompensateCrappyAndroidPaths.getPath(ActivityManageSpecificProfile.this, data.getData()); + setNotificationsRingtone(new File(ringTonePath)); + } + break; + } + case intentCodeRingtonePickerNotificationsFile: + { + String ringTonePath = CompensateCrappyAndroidPaths.getPath(ActivityManageSpecificProfile.this, data.getData()); + setNotificationsRingtone(new File(ringTonePath)); + break; + } + default: + ; + } + } + } + + public String getRealPathFromURI(Uri uri) + { + String[] projection = { MediaStore.Images.Media.DATA }; + Cursor cursor = getContentResolver().query(uri, projection, null, null, null); + if (cursor == null) return null; + int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA); + cursor.moveToFirst(); + String s=cursor.getString(column_index); + cursor.close(); + return s; + } +} \ No newline at end of file diff --git a/app/src/main/java/com/jens/automation2/ActivityManageSpecificRule.java b/app/src/main/java/com/jens/automation2/ActivityManageSpecificRule.java new file mode 100644 index 0000000..d9c4c42 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivityManageSpecificRule.java @@ -0,0 +1,1674 @@ +package com.jens.automation2; + +import android.app.Activity; +import android.app.AlertDialog; +import android.app.Dialog; +import android.app.ProgressDialog; +import android.content.Context; +import android.content.DialogInterface; +import android.content.Intent; +import android.content.pm.PackageManager; +import android.os.AsyncTask; +import android.os.Build; +import android.os.Bundle; +import android.text.InputType; +import android.text.util.Linkify; +import android.view.MotionEvent; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.View.OnTouchListener; +import android.view.ViewGroup; +import android.view.inputmethod.InputMethodManager; +import android.widget.AdapterView; +import android.widget.AdapterView.OnItemClickListener; +import android.widget.AdapterView.OnItemLongClickListener; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.CheckBox; +import android.widget.CompoundButton; +import android.widget.CompoundButton.OnCheckedChangeListener; +import android.widget.EditText; +import android.widget.ImageView; +import android.widget.ListAdapter; +import android.widget.ListView; +import android.widget.TextView; +import android.widget.Toast; + +import com.jens.automation2.Action.Action_Enum; +import com.jens.automation2.Trigger.Trigger_Enum; +import com.jens.automation2.receivers.ActivityDetectionReceiver; +import com.jens.automation2.receivers.NfcReceiver; + +import java.util.ArrayList; +import java.util.Collections; + +public class ActivityManageSpecificRule extends Activity +{ + public Context context; + private Button cmdTriggerAdd, cmdActionAdd, cmdSaveRule; + private ListView triggerListView, actionListView; + private EditText etRuleName; + private CheckBox chkRuleActive, chkRuleToggle; + private static ActivityManageSpecificRule instance = null; + ImageView imageHelpButton; + + private static ProgressDialog progressDialog = null; + + private static Trigger_Enum triggerType; + private static boolean triggerParameter; + private static PointOfInterest triggerPoi; + private static String triggerProcess; + private static int triggerBattery; + private static double triggerSpeed; + private static double triggerNoise; + private static TimeFrame triggerTimeFrame; + private static String triggerWifiName; + + private static Rule ruleToEdit; + private static boolean newRule; + + private static Trigger newTrigger; + private static Action newAction; + + ArrayAdapter triggerListViewAdapter; + ArrayAdapter actionListViewAdapter; + + int editIndex = 0; + + final static int requestCodeActionTriggerUrlAdd = 1000; + final static int requestCodeActionTriggerUrlEdit = 1001; + final static int requestCodeTriggerTimeframeAdd = 2000; + final static int requestCodeTriggerTimeframeEdit = 2001; + final static int requestCodeActionStartActivityAdd = 3000; + final static int requestCodeActionStartActivityEdit = 3001; + final static int requestCodeTriggerNfcTagAdd = 4000; + final static int requestCodeTriggerNfcTagEdit = 4001; + final static int requestCodeActionSpeakTextAdd = 5000; + final static int requestCodeActionSpeakTextEdit = 1001; + final static int requestCodeTriggerBluetoothAdd = 6000; + final static int requestCodeTriggerBluetoothEdit = 6001; + final static int requestCodeActionScreenBrightnessAdd = 401; + final static int requestCodeActionScreenBrightnessEdit = 402; + final static int requestCodeActionSendTextMessage = 7001; + + public static ActivityManageSpecificRule getInstance() + { + if(instance == null) + instance = new ActivityManageSpecificRule(); + + return instance; + } + + @Override + protected void onCreate(Bundle savedInstanceState) + { + context = this; + super.onCreate(savedInstanceState); + setContentView(R.layout.manage_specific_rule); + + instance = this; + + cmdTriggerAdd = (Button)findViewById(R.id.cmdTriggerAdd); + cmdActionAdd = (Button)findViewById(R.id.cmdActionAdd); + triggerListView = (ListView)findViewById(R.id.lvTriggerListView); + actionListView = (ListView)findViewById(R.id.lvActionListView); + etRuleName = (EditText)findViewById(R.id.etRuleName); + cmdSaveRule = (Button)findViewById(R.id.cmdSaveRule); + chkRuleActive = (CheckBox)findViewById(R.id.chkRuleActive); + chkRuleToggle = (CheckBox)findViewById(R.id.chkRuleToggle); + imageHelpButton = (ImageView)findViewById(R.id.imageHelpButton); + + //decide if it will be created anew or loaded to edit an existing one + if(ActivityMainRules.ruleToEdit == null) + { + // new rule + Miscellaneous.logEvent("i", "Rule", "Cache empty, assuming create request.", 3); + newRule = true; + ruleToEdit = new Rule(); + ruleToEdit.setTriggerSet(new ArrayList()); + ruleToEdit.setActionSet(new ArrayList()); + triggerListViewAdapter = new ArrayAdapter(this, R.layout.text_view_for_poi_listview_mediumtextsize, ruleToEdit.getTriggerSet()); + actionListViewAdapter = new ArrayAdapter(this, R.layout.text_view_for_poi_listview_mediumtextsize, ruleToEdit.getActionSet()); + } + else + { + // change existing rule + Miscellaneous.logEvent("i", "Rule", "Cache not empty, assuming change request.", 3); + newRule = false; + ruleToEdit = ActivityMainRules.ruleToEdit; + triggerListViewAdapter = new ArrayAdapter(this, R.layout.text_view_for_poi_listview_mediumtextsize, ruleToEdit.getTriggerSet()); + actionListViewAdapter = new ArrayAdapter(this, R.layout.text_view_for_poi_listview_mediumtextsize, ruleToEdit.getActionSet()); + loadVariablesIntoGui(); + } + + cmdTriggerAdd.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + hideKeyboard(); + newTrigger = new Trigger(); + getTriggerTypeDialog(context).show(); + } + }); + + cmdActionAdd.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + hideKeyboard(); + getActionTypeDialog().show(); + } + }); + + cmdSaveRule.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + if(newRule) + { + Miscellaneous.logEvent("i", "Rule", "Will create a new rule.", 3); + loadFormValuesToVariable(); + if(ruleToEdit.create(context)) + { + ActivityPermissions.getRequiredPermissions(false); + finish(); + } + else + Toast.makeText(ActivityManageSpecificRule.this, getResources().getString(R.string.errorWritingConfig), Toast.LENGTH_LONG).show(); + } + else + { + Miscellaneous.logEvent("i", "Rule", "Will change an existing rule.", 3); + loadFormValuesToVariable(); + if(ruleToEdit.change(context)) + { + ActivityPermissions.getRequiredPermissions(false); + finish(); + } + else + Toast.makeText(ActivityManageSpecificRule.this, getResources().getString(R.string.errorWritingConfig), Toast.LENGTH_LONG).show(); + } + } + }); + + triggerListView.setClickable(true); + actionListView.setClickable(true); + + triggerListView.setOnItemLongClickListener(new OnItemLongClickListener() + { + @Override + public boolean onItemLongClick(AdapterView arg0, View arg1, int arg2, long arg3) + { + getTriggerDeleteDialog(context, (Trigger)triggerListView.getItemAtPosition(arg2)).show(); + return false; + } + }); + triggerListView.setOnItemClickListener(new OnItemClickListener() + { + @Override + public void onItemClick(AdapterView arg0, View arg1, int arg2, long arg3) + { + editIndex = arg2; + Trigger selectedTrigger = (Trigger)triggerListView.getItemAtPosition(arg2); + switch(selectedTrigger.getTriggerType()) + { +// case batteryLevel: +// break; +// case charging: +// break; +// case noiseLevel: +// break; +// case pointOfInterest: +// break; +// case process_started_stopped: +// break; +// case speed: +// break; + case timeFrame: + ActivityManageTimeFrame.editedTimeFrameTrigger = selectedTrigger; + Intent timeFrameEditor = new Intent(ActivityManageSpecificRule.this, ActivityManageTimeFrame.class); + startActivityForResult(timeFrameEditor, requestCodeTriggerTimeframeEdit); + break; +// case usb_host_connection: +// break; +// case wifiConnection: +// break; + case bluetoothConnection: + ActivityManageBluetoothTrigger.editedBluetoothTrigger = selectedTrigger; + Intent bluetoothEditor = new Intent(ActivityManageSpecificRule.this, ActivityManageBluetoothTrigger.class); + startActivityForResult(bluetoothEditor, requestCodeTriggerBluetoothEdit); + break; + default: + break; + } + } + }); + triggerListView.setOnTouchListener(new OnTouchListener() + { + @Override + public boolean onTouch(View v, MotionEvent event) + { + v.getParent().requestDisallowInterceptTouchEvent(true); + return false; + } + }); + + actionListView.setOnItemLongClickListener(new OnItemLongClickListener() + { + public boolean onItemLongClick(AdapterView arg0, View arg1, int arg2, long arg3) + { + getActionDeleteDialog(context, (Action)actionListView.getItemAtPosition(arg2)).show(); + return false; + } + }); + actionListView.setOnItemClickListener(new OnItemClickListener() + { + // editing triggers + @Override + public void onItemClick(AdapterView arg0, View arg1, int arg2, long arg3) + { + editIndex = arg2; + Action a = (Action)actionListView.getItemAtPosition(arg2); + switch(a.getAction()) + { +// case changeSoundProfile: +// break; +// case disableScreenRotation: +// break; +// case enableScreenRotation: +// break; +// case setAirplaneMode: +// break; + case startOtherActivity: + Intent intent = new Intent(ActivityManageSpecificRule.this, ActivityManageStartActivity.class); + ActivityManageStartActivity.resultingAction = a; + intent.putExtra("edit", true); + startActivityForResult(intent, requestCodeActionStartActivityEdit); + break; + case triggerUrl: + Intent activityEditTriggerUrlIntent = new Intent(ActivityManageSpecificRule.this, ActivityEditTriggerUrl.class); +// activityEditTriggerUrlIntent.putExtra("urlToTrigger", a.getParameter2()); + ActivityEditTriggerUrl.resultingAction = a; + activityEditTriggerUrlIntent.putExtra("edit", true); + startActivityForResult(activityEditTriggerUrlIntent, requestCodeActionTriggerUrlEdit); + break; +// case turnBluetoothOff: +// break; +// case turnBluetoothOn: +// break; +// case turnUsbTetheringOff: +// break; +// case turnUsbTetheringOn: +// break; +// case turnWifiOff: +// break; +// case turnWifiOn: +// break; +// case turnWifiTetheringOff: +// break; +// case turnWifiTetheringOn: +// break; +// case waitBeforeNextAction: +// break; +// case wakeupDevice: +// break; + case speakText: + Intent activitySpeakTextIntent = new Intent(ActivityManageSpecificRule.this, ActivityEditSpeakText.class); + ActivityEditSpeakText.resultingAction = a; + activitySpeakTextIntent.putExtra("edit", true); + startActivityForResult(activitySpeakTextIntent, requestCodeActionSpeakTextEdit); + break; + case sendTextMessage: + Intent activitySendTextMessageIntent = new Intent(ActivityManageSpecificRule.this, ActivityEditSendTextMessage.class); + ActivityEditSendTextMessage.resultingAction = a; + activitySendTextMessageIntent.putExtra("edit", true); + startActivityForResult(activitySendTextMessageIntent, requestCodeActionSendTextMessage); + break; + case setScreenBrightness: + Intent activityEditScreenBrightnessIntent = new Intent(ActivityManageSpecificRule.this, ActivityManageBrightnessSetting.class); +// ActivityEditTriggerUrl.resultingAction = a; + activityEditScreenBrightnessIntent.putExtra("autoBrightness", a.getParameter1()); + activityEditScreenBrightnessIntent.putExtra("brightnessValue", Integer.parseInt(a.getParameter2())); + startActivityForResult(activityEditScreenBrightnessIntent, requestCodeActionScreenBrightnessEdit); + break; + default: + Miscellaneous.logEvent("w", "Edit action", "Editing of action type " + a.getAction().toString() + " not implemented, yet.", 4); + break; + } + } + }); + actionListView.setOnTouchListener(new OnTouchListener() + { + @Override + public boolean onTouch(View v, MotionEvent event) + { + v.getParent().requestDisallowInterceptTouchEvent(true); + return false; + } + }); + + chkRuleToggle.setOnCheckedChangeListener(new OnCheckedChangeListener() + { + private boolean guiEditing = false; + + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) + { + if(!guiEditing) + if(!plausibilityCheck()) + { + guiEditing = true; + chkRuleToggle.setChecked(false); + guiEditing = false; + Toast.makeText(ActivityManageSpecificRule.this, getResources().getString(R.string.toggleNotAllowed), Toast.LENGTH_LONG).show(); + } + } + }); + + imageHelpButton.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + // Open help popup + Miscellaneous.messageBox(getResources().getString(R.string.whatsThis), getResources().getString(R.string.helpTextToggable), ActivityManageSpecificRule.this).show(); + } + }); + } + + protected boolean plausibilityCheck() + { + boolean nfcFound = false; + if(chkRuleToggle.isChecked()) + { + for(Trigger trigger : ruleToEdit.getTriggerSet()) + { + if(trigger.getTriggerType().equals(Trigger_Enum.nfcTag)) + nfcFound = true; + } + if(!nfcFound) + return false; + } + + return true; + } + + protected void loadFormValuesToVariable() + { + ruleToEdit.setName(etRuleName.getText().toString()); + ruleToEdit.setRuleActive(chkRuleActive.isChecked()); + ruleToEdit.setRuleToggle(chkRuleToggle.isChecked()); + } + + private void loadVariablesIntoGui() + { + // Set all gui fields to the values of the to-be-edited-object + + etRuleName.setText(ruleToEdit.getName()); + chkRuleActive.setChecked(ruleToEdit.isRuleActive()); + chkRuleToggle.setChecked(ruleToEdit.isRuleToggle()); + + refreshTriggerList(); + refreshActionList(); + } + + private AlertDialog getTriggerTypeDialog(final Context myContext) + { + final ArrayList items = new ArrayList(); + + CharSequence[] types = Trigger.getTriggerTypesAsArray(); + CharSequence[] typesLong = Trigger.getTriggerTypesStringAsArray(myContext); + + for(int i=0; i(this, android.R.layout.select_dialog_item, android.R.id.text1, items) + { + public View getView(int position, View convertView, ViewGroup parent) + { + //User super class to create the View + View v = super.getView(position, convertView, parent); + + TextView tv = (TextView)v.findViewById(android.R.id.text1); + + //Put the image on the TextView + tv.setCompoundDrawablesWithIntrinsicBounds(items.get(position).icon, 0, 0, 0); + + //Add margin between image and text (support various screen densities) + int dp5 = (int) (5 * getResources().getDisplayMetrics().density + 0.5f); + tv.setCompoundDrawablePadding(dp5); + + return v; + } + }; + + AlertDialog.Builder builder = new AlertDialog.Builder(this) + .setTitle(getResources().getString(R.string.selectTypeOfTrigger)) + .setAdapter(adapter, new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog, int which) + { + triggerType = Trigger_Enum.values()[which]; + + String[] booleanChoices = null; + if(triggerType == Trigger_Enum.pointOfInterest) + { + if(PointOfInterest.getPointOfInterestCollection() != null && PointOfInterest.getPointOfInterestCollection().size() > 0) + booleanChoices = new String[]{getResources().getString(R.string.entering), getResources().getString(R.string.leaving)}; + else + { + Toast.makeText(myContext, getResources().getString(R.string.noPoisSpecified), Toast.LENGTH_LONG).show(); + return; + } + } + else if(triggerType == Trigger_Enum.timeFrame) + { + newTrigger.setTriggerType(Trigger_Enum.timeFrame); + ActivityManageTimeFrame.editedTimeFrameTrigger = newTrigger; + Intent timeFrameEditor = new Intent(myContext, ActivityManageTimeFrame.class); + startActivityForResult(timeFrameEditor, requestCodeTriggerTimeframeAdd); + return; + } + else if(triggerType == Trigger_Enum.charging) + booleanChoices = new String[]{getResources().getString(R.string.started), getResources().getString(R.string.stopped)}; + else if(triggerType == Trigger_Enum.usb_host_connection) + booleanChoices = new String[]{getResources().getString(R.string.connected), getResources().getString(R.string.disconnected)}; + else if(triggerType == Trigger_Enum.speed | triggerType == Trigger_Enum.noiseLevel | triggerType == Trigger_Enum.batteryLevel) + booleanChoices = new String[]{getResources().getString(R.string.exceeds), getResources().getString(R.string.dropsBelow)}; + else if(triggerType == Trigger_Enum.wifiConnection) + booleanChoices = new String[]{getResources().getString(R.string.connected), getResources().getString(R.string.disconnected)}; + else if(triggerType == Trigger_Enum.process_started_stopped) + booleanChoices = new String[]{getResources().getString(R.string.started), getResources().getString(R.string.stopped)}; + else if(triggerType == Trigger_Enum.airplaneMode) + booleanChoices = new String[]{getResources().getString(R.string.activated), getResources().getString(R.string.deactivated)}; + else if(triggerType == Trigger_Enum.roaming) + booleanChoices = new String[]{getResources().getString(R.string.activated), getResources().getString(R.string.deactivated)}; + else if(triggerType == Trigger_Enum.phoneCall) + booleanChoices = new String[]{getResources().getString(R.string.started), getResources().getString(R.string.stopped)}; + else if(triggerType == Trigger_Enum.activityDetection) + { + if(ActivityDetectionReceiver.isPlayServiceAvailable()) + { + newTrigger.setTriggerType(Trigger_Enum.activityDetection); + getTriggerActivityDetectionDialog().show(); + } + else + Toast.makeText(myContext, getResources().getString(R.string.triggerOnlyAvailableIfPlayServicesInstalled), Toast.LENGTH_LONG).show(); + return; + } + else if(triggerType == Trigger_Enum.nfcTag) + { + if(NfcReceiver.checkNfcRequirements(ActivityManageSpecificRule.this, true)) + { + newTrigger.setTriggerType(Trigger_Enum.nfcTag); + Intent nfcEditor = new Intent(myContext, ActivityManageNfc.class); + startActivityForResult(nfcEditor, requestCodeTriggerNfcTagAdd); + return; + } + } + else if(triggerType == Trigger_Enum.bluetoothConnection) + { + if(!getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH)) + Miscellaneous.messageBox("Bluetooth", getResources().getString(R.string.deviceDoesNotHaveBluetooth), ActivityManageSpecificRule.this).show();; + + newTrigger.setTriggerType(Trigger_Enum.bluetoothConnection); + ActivityManageBluetoothTrigger.editedBluetoothTrigger = newTrigger; + Intent bluetoothEditor = new Intent(myContext, ActivityManageBluetoothTrigger.class); + startActivityForResult(bluetoothEditor, requestCodeTriggerBluetoothAdd); + return; + } + else if(triggerType == Trigger_Enum.headsetPlugged) + booleanChoices = new String[]{getResources().getString(R.string.connected), getResources().getString(R.string.disconnected)}; + + if(triggerType == Trigger_Enum.nfcTag) + { + if (NfcReceiver.checkNfcRequirements(ActivityManageSpecificRule.this, true)) + getTriggerParamterDialog(context, booleanChoices).show(); + } + else + getTriggerParamterDialog(context, booleanChoices).show(); + } + }); + + return builder.create(); + } + private AlertDialog getTriggerParamterDialog(final Context myContext, final String[] choices) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(context); + alertDialogBuilder.setTitle(getResources().getString(R.string.selectTypeOfTrigger)); + alertDialogBuilder.setItems(choices, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + if(which==0) + newTrigger.setTriggerParameter(true); + else + newTrigger.setTriggerParameter(false); + + if(triggerType == Trigger_Enum.pointOfInterest) + { + ArrayList choices = new ArrayList(); + choices.add("< " + getResources().getString(R.string.none) + " >"); + for(String s : PointOfInterest.getNamesInArray()) + choices.add(s); + + getTriggerPoiDialog(myContext, choices.toArray(new String[choices.size()])).show(); + } + else if(triggerType == Trigger_Enum.batteryLevel) + { + ArrayList choicesList = new ArrayList(); + for(int i=1; i<=100; i+=1) + choicesList.add(String.valueOf(i) + " %"); + String[] choices = (String[]) choicesList.toArray(new String[choicesList.size()]); + getTriggerBatteryDialog(myContext, choices).show(); + } + else if(triggerType == Trigger_Enum.speed) + { + ArrayList choicesList = new ArrayList(); + for(int i=5; i<=150; i+=5) + choicesList.add(String.valueOf(i) + " km/h"); + String[] choices = (String[]) choicesList.toArray(new String[choicesList.size()]); + getTriggerSpeedDialog(myContext, choices).show(); + } + else if(triggerType == Trigger_Enum.noiseLevel) + { + ArrayList choicesList = new ArrayList(); + for(int i=5; i<=150; i+=5) + choicesList.add(String.valueOf(i) + " dB"); + String[] choices = (String[]) choicesList.toArray(new String[choicesList.size()]); + getTriggerNoiseDialog(myContext, choices).show(); + } +// else if(triggerType.equals(Trigger.Event_Enum.timeFrame)) +// { +// newTrigger.setTriggerType(Trigger.Event_Enum.timeFrame); +// ActivityManageTimeFrame.editedTimeFrameTrigger = null; +// Intent timeFrameEditor = new Intent(myContext, ActivityManageTimeFrame.class); +// startActivityForResult(timeFrameEditor, 2000); +// } + else if(triggerType.equals(Trigger_Enum.wifiConnection)) + { + newTrigger.setTriggerType(Trigger_Enum.wifiConnection); + getTriggerWifiDialog(myContext).show(); + } + else if(triggerType.equals(Trigger_Enum.process_started_stopped)) + { + progressDialog = ProgressDialog.show(myContext, null, getResources().getString(R.string.gettingListOfInstalledApplications), true, false); + newTrigger.setTriggerType(Trigger_Enum.process_started_stopped); + new GenerateApplicationSelectionsDialogTask().execute(ActivityManageSpecificRule.this); +// getTriggerRunningProcessDialog1(myContext).show(); + } + else if(triggerType.equals(Trigger_Enum.phoneCall)) + { + newTrigger.setTriggerType(Trigger_Enum.phoneCall); + getTriggerPhoneDirectionDialog(myContext).show(); + } + else if(triggerType.equals(Trigger_Enum.headsetPlugged)) + { + newTrigger.setTriggerType(Trigger_Enum.headsetPlugged); + getTriggerHeadphoneDialog(myContext).show(); + } + else + { + newTrigger.setTriggerType(triggerType); + ruleToEdit.getTriggerSet().add(newTrigger); + refreshTriggerList(); + } + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + private AlertDialog getTriggerBatteryDialog(final Context myContext, final String[] choices) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(context); + alertDialogBuilder.setTitle(getResources().getString(R.string.selectBattery)); + alertDialogBuilder.setItems(choices, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + try + { + triggerBattery = (which+1); + newTrigger.setTriggerType(Trigger_Enum.batteryLevel); + newTrigger.setBatteryLevel(triggerBattery); +// Log.i("test", newTrigger.toString()); +// Log.i("test", String.valueOf(newTrigger.getBatteryLevel())); + ruleToEdit.getTriggerSet().add(newTrigger); + refreshTriggerList(); + } + catch (Exception e) + { + e.printStackTrace(); + } + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + private AlertDialog getTriggerSpeedDialog(final Context myContext, final String[] choices) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(context); + alertDialogBuilder.setTitle(getResources().getString(R.string.selectSpeed)); + alertDialogBuilder.setItems(choices, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + try + { + triggerSpeed = (which+1)*5; + newTrigger.setTriggerType(Trigger_Enum.speed); + newTrigger.setSpeed(triggerSpeed); + ruleToEdit.getTriggerSet().add(newTrigger); + refreshTriggerList(); + } + catch (Exception e) + { + e.printStackTrace(); + } + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + private AlertDialog getTriggerNoiseDialog(final Context myContext, final String[] choices) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(context); + alertDialogBuilder.setTitle(getResources().getString(R.string.selectNoiseLevel)); + alertDialogBuilder.setItems(choices, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + try + { + triggerNoise = (which+1)*5; + newTrigger.setTriggerType(Trigger_Enum.noiseLevel); + newTrigger.setNoiseLevelDb(Math.round(triggerNoise)); + ruleToEdit.getTriggerSet().add(newTrigger); + refreshTriggerList(); + + /* + * Comment about the physical reference value. + */ + if(!Rule.isAnyRuleUsing(Trigger_Enum.noiseLevel)) + { + AlertDialog noiseHintDialog = Miscellaneous.messageBox(myContext.getResources().getString(R.string.hint), myContext.getResources().getString(R.string.noiseDetectionHint), myContext); + noiseHintDialog.show(); + Linkify.addLinks((TextView) noiseHintDialog.findViewById(android.R.id.message), Linkify.ALL); +// ((TextView)noiseHintDialog.findViewById(android.R.id.message)).setMovementMethod(LinkMovementMethod.getInstance()); + } + } + catch (Exception e) + { + e.printStackTrace(); + } + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + private AlertDialog getTriggerWifiDialog(final Context myContext) + { + AlertDialog.Builder alertDialog = new AlertDialog.Builder(this); + + alertDialog.setTitle(myContext.getResources().getString(R.string.wifiName)); + alertDialog.setMessage(myContext.getResources().getString(R.string.enterWifiName)); + + // Set an EditText view to get user input + final EditText input = new EditText(this); + alertDialog.setView(input); + + alertDialog.setPositiveButton("Ok", new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog, int whichButton) + { + newTrigger.setWifiName(input.getText().toString()); + ruleToEdit.getTriggerSet().add(newTrigger); + refreshTriggerList(); + } + }); + + alertDialog.setNegativeButton(myContext.getResources().getString(R.string.cancel), new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog, int whichButton) + { + // Canceled. + } + }); + + return alertDialog.create(); + } + private AlertDialog getTriggerPhoneDirectionDialog(final Context myContext) + { + AlertDialog.Builder alertDialog = new AlertDialog.Builder(this); + + alertDialog.setTitle(myContext.getResources().getString(R.string.phoneDirection)); + String[] choices = new String[] { myContext.getResources().getString(R.string.any), myContext.getResources().getString(R.string.incoming), myContext.getResources().getString(R.string.outgoing) }; + alertDialog.setItems(choices, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + newTrigger.setPhoneDirection(which); + getTriggerPhoneNumberDialog(ActivityManageSpecificRule.this).show(); + } + }); + + return alertDialog.create(); + } + private AlertDialog getTriggerPhoneNumberDialog(final Context myContext) + { + AlertDialog.Builder alertDialog = new AlertDialog.Builder(this); + + alertDialog.setTitle(myContext.getResources().getString(R.string.phoneNumber)); + alertDialog.setMessage(myContext.getResources().getString(R.string.enterPhoneNumber)); + + // Set an EditText view to get user input + final EditText input = new EditText(this); + input.setInputType(InputType.TYPE_CLASS_PHONE); + alertDialog.setView(input); + + alertDialog.setPositiveButton("Ok", new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog, int whichButton) + { + String number = input.getText().toString(); + if(number.length() == 0) + number = "any"; + + newTrigger.setPhoneNumber(number); + ruleToEdit.getTriggerSet().add(newTrigger); + refreshTriggerList(); + } + }); + + alertDialog.setNegativeButton(myContext.getResources().getString(R.string.cancel), new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog, int whichButton) + { + // Canceled. + } + }); + + return alertDialog.create(); + } + private AlertDialog getTriggerPoiDialog(final Context myContext, final String[] choices) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(context); + alertDialogBuilder.setTitle(getResources().getString(R.string.selectPoi)); + alertDialogBuilder.setItems(choices, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + try + { + if(which > 0) + triggerPoi = PointOfInterest.getByName(choices[which]); + else + triggerPoi = null; + + newTrigger.setTriggerType(Trigger_Enum.pointOfInterest); + newTrigger.setPointOfInterest(triggerPoi); + ruleToEdit.getTriggerSet().add(newTrigger); + refreshTriggerList(); + } + catch (Exception e) + { + e.printStackTrace(); + } + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + private AlertDialog getTriggerHeadphoneDialog(final Context myContext) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(context); + alertDialogBuilder.setTitle(getResources().getString(R.string.headphoneSelectType)); + alertDialogBuilder.setItems(new String[]{ myContext.getResources().getString(R.string.headphoneSimple), myContext.getResources().getString(R.string.headphoneMicrophone), myContext.getResources().getString(R.string.headphoneAny) }, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + try + { + newTrigger.setHeadphoneType(which); + ruleToEdit.getTriggerSet().add(newTrigger); + refreshTriggerList(); + } + catch (Exception e) + { + e.printStackTrace(); + } + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + private AlertDialog getTriggerActivityDetectionDialog() + { + AlertDialog.Builder alertDialog = new AlertDialog.Builder(this); + + alertDialog.setTitle(Miscellaneous.getAnyContext().getResources().getString(R.string.selectTypeOfActivity)); + String[] choices = ActivityDetectionReceiver.getAllDescriptions(); + alertDialog.setItems(choices, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + newTrigger.setActivityDetectionType(ActivityDetectionReceiver.getAllTypes()[which]); + ruleToEdit.getTriggerSet().add(newTrigger); + refreshTriggerList(); + } + }); + + return alertDialog.create(); + } + + private static class GenerateApplicationSelectionsDialogTask extends AsyncTask + { + @Override + protected String[] doInBackground(ActivityManageSpecificRule... params) + { +// Looper.prepare(); + final String[] applicationArray = ActivityManageStartActivity.getApplicationNameListString(params[0]); + return applicationArray; + } + + @Override + protected void onPostExecute(String[] result) + { + if(progressDialog != null) + { + progressDialog.dismiss(); + progressDialog = null; + } + + ActivityManageSpecificRule.getInstance().showProcessDialog(result); + } + } + + void showProcessDialog(String[] programStrings) + { + getTriggerRunningProcessDialog1(ActivityManageSpecificRule.this, programStrings).show(); + } + + private AlertDialog getTriggerRunningProcessDialog1(final Context myContext, final String[] applicationArray) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(myContext); + alertDialogBuilder.setTitle(myContext.getResources().getString(R.string.selectApplication)); + alertDialogBuilder.setItems(applicationArray, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + String applicationName = applicationArray[which]; + getTriggerRunningProcessDialog2(myContext, applicationName).show(); + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + +// Log.i("Amount of Applications", String.valueOf(applicationArray.length)); +// Log.i("Amount of Packages", String.valueOf(ActivityManageStartActivity.getPackageListString(myContext).length)); + + return alertDialog; + } + + private AlertDialog getTriggerRunningProcessDialog2(final Context myContext, String applicationName) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(myContext); + alertDialogBuilder.setTitle(myContext.getResources().getString(R.string.selectPackageOfApplication)); + final String[] packageArray = ActivityManageStartActivity.getPackageListString(myContext, applicationName); + alertDialogBuilder.setItems(packageArray, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + String packageName = packageArray[which]; + getTriggerRunningProcessDialog3(myContext, packageName).show(); + Miscellaneous.messageBox(getResources().getString(R.string.hint), getResources().getString(R.string.chooseActivityHint), ActivityManageSpecificRule.this).show(); + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + + private AlertDialog getTriggerRunningProcessDialog3(final Context myContext, final String packageName) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(myContext); + alertDialogBuilder.setTitle(myContext.getResources().getString(R.string.selectActivityToBeStarted)); + final String activityArray[] = ActivityManageStartActivity.getActivityListForPackageName(packageName); + alertDialogBuilder.setItems(activityArray, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + triggerProcess = activityArray[which]; + newTrigger.setTriggerType(Trigger_Enum.process_started_stopped); + newTrigger.setProcessName(triggerProcess); + ruleToEdit.getTriggerSet().add(newTrigger); + refreshTriggerList(); + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + + @Override + protected void onActivityResult(int requestCode, int resultCode, Intent data) + { + super.onActivityResult(requestCode, resultCode, data); + + if(requestCode == requestCodeActionTriggerUrlAdd) + { + if(resultCode == RESULT_OK) + { + //add TriggerUrl + ruleToEdit.getActionSet().add(ActivityEditTriggerUrl.resultingAction); + this.refreshActionList(); + } + } + else if(requestCode == requestCodeActionTriggerUrlEdit) + { + if(resultCode == RESULT_OK) + { + //edit TriggerUrl + this.refreshActionList(); + } + } + else if(requestCode == requestCodeTriggerTimeframeAdd) + { + //add TimeFrame + if(resultCode == RESULT_OK && ActivityManageTimeFrame.editedTimeFrameTrigger != null) + { + ruleToEdit.getTriggerSet().add(newTrigger); + this.refreshTriggerList(); + } + else + Miscellaneous.logEvent("w", "TimeFrameEdit", "No timeframe returned. Assuming abort.", 5); + } + else if(requestCode == requestCodeTriggerTimeframeEdit) + { + //edit TimeFrame + if(resultCode == RESULT_OK && ActivityManageTimeFrame.editedTimeFrameTrigger != null) + { + this.refreshTriggerList(); + } + else + Miscellaneous.logEvent("w", "TimeFrameEdit", "No timeframe returned. Assuming abort.", 5); + } + else if(requestCode == requestCodeActionStartActivityAdd) + { + // manage start of other activity + if(resultCode == RESULT_OK) + { + newAction = ActivityManageStartActivity.resultingAction; + ruleToEdit.getActionSet().add(newAction); + this.refreshActionList(); + } + } + else if(requestCode == requestCodeActionStartActivityEdit) + { + // manage start of other activity + if(resultCode == RESULT_OK) + { + newAction = ActivityManageStartActivity.resultingAction; +// ruleToEdit.getActionSet().add(newAction); + this.refreshActionList(); + } + } + else if(requestCode == requestCodeTriggerNfcTagAdd) + { + //add TimeFrame + if(resultCode == RESULT_OK && ActivityManageNfc.generatedId != null) + { + newTrigger.setNfcTagId(ActivityManageNfc.generatedId); + ruleToEdit.getTriggerSet().add(newTrigger); + this.refreshTriggerList(); + } + else + Miscellaneous.logEvent("w", "ActivityManageNfc", "No nfc id returned. Assuming abort.", 5); + } + else if(requestCode == requestCodeActionSpeakTextAdd) + { + if(resultCode == RESULT_OK) + { + //add SpeakText + ruleToEdit.getActionSet().add(ActivityEditSpeakText.resultingAction); + this.refreshActionList(); + } + } + else if(requestCode == requestCodeActionSpeakTextEdit) + { + if(resultCode == RESULT_OK) + { + //add SpeakText + ruleToEdit.getActionSet().add(ActivityEditSendTextMessage.resultingAction); + this.refreshActionList(); + } + } + else if(requestCode == requestCodeTriggerBluetoothAdd) + { + //add bluetooth trigger + if(resultCode == RESULT_OK && ActivityManageBluetoothTrigger.editedBluetoothTrigger != null) + { + ruleToEdit.getTriggerSet().add(newTrigger); + this.refreshTriggerList(); + } + else + Miscellaneous.logEvent("w", "BluetoothTriggerEdit", "No bluetooth trigger returned. Assuming abort.", 5); + } + else if(requestCode == requestCodeTriggerBluetoothEdit) + { + //edit bluetooth trigger + if(resultCode == RESULT_OK && ActivityManageBluetoothTrigger.editedBluetoothTrigger != null) + { + this.refreshTriggerList(); + } + else + Miscellaneous.logEvent("w", "BluetoothTriggerEdit", "No bluetooth trigger returned. Assuming abort.", 5); + } + else if(requestCode == requestCodeActionScreenBrightnessAdd) + { + if(resultCode == RESULT_OK) + { + newAction.setParameter1(data.getBooleanExtra("autoBrightness", false)); + newAction.setParameter2(String.valueOf(data.getIntExtra("brightnessValue", 0))); + ruleToEdit.getActionSet().add(newAction); + this.refreshActionList(); + } + } + else if(requestCode == requestCodeActionScreenBrightnessEdit) + { + if(resultCode == RESULT_OK) + { + if(data.hasExtra("autoBrightness")) + ruleToEdit.getActionSet().get(editIndex).setParameter1(data.getBooleanExtra("autoBrightness", false)); + + if(data.hasExtra("brightnessValue")) + ruleToEdit.getActionSet().get(editIndex).setParameter2(String.valueOf(data.getIntExtra("brightnessValue", 0))); + + this.refreshActionList(); + } + } + + //TODO: Check with has data been changed or something like that. + /*try + { + Miscellaneous.logEvent("i", "ActivityManageSpecificRule", getResources().getString(R.string.noDataChangedReadingAnyway), 4); + XmlFileInterface.readFile(); + } + catch (FileNotFoundException e) + { + Miscellaneous.logEvent("e", "ActivityManageSpecificRule", getResources().getString(R.string.errorReadingPoisAndRulesFromFile) + ": " + Log.getStackTraceString(e), 5); + }*/ + } + + protected Dialog getActionTypeDialog() + { + final ArrayList items = new ArrayList(); + + CharSequence[] types = Action.getActionTypesAsArray(); + CharSequence[] typesLong = Action.getActionTypesFullNameStringAsArray(this); + + for(int i=0; i(this, android.R.layout.select_dialog_item, android.R.id.text1, items) + ListAdapter adapter = new ArrayAdapter(this, android.R.layout.select_dialog_item, android.R.id.text1, items) + { + public View getView(int position, View convertView, ViewGroup parent) + { + //User super class to create the View + View v = super.getView(position, convertView, parent); + + TextView tv = (TextView)v.findViewById(android.R.id.text1); + + //Put the image on the TextView + tv.setCompoundDrawablesWithIntrinsicBounds(items.get(position).icon, 0, 0, 0); + + //Add margin between image and text (support various screen densities) + int dp5 = (int) (5 * getResources().getDisplayMetrics().density + 0.5f); + tv.setCompoundDrawablePadding(dp5); + + return v; + } + }; + + AlertDialog.Builder builder = new AlertDialog.Builder(this) + .setTitle(getResources().getString(R.string.selectTypeOfAction)) + .setAdapter(adapter, new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog, int which) + { + newAction = new Action(); + + if(Action.getActionTypesAsArray()[which].toString().equals(Action_Enum.triggerUrl.toString())) + { + //launch other activity to enter a url and parameters; + newAction.setAction(Action_Enum.triggerUrl); + ActivityEditTriggerUrl.resultingAction = null; + Intent editTriggerIntent = new Intent(context, ActivityEditTriggerUrl.class); + startActivityForResult(editTriggerIntent, 1000); + } + else if(Action.getActionTypesAsArray()[which].toString().equals(Action_Enum.setWifi.toString())) + { + newAction.setAction(Action_Enum.setWifi); + if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) + Toast.makeText(context, context.getResources().getString(R.string.android10WifiToggleNotice), Toast.LENGTH_LONG).show(); + getActionParameter1Dialog(ActivityManageSpecificRule.this).show(); + } + else if(Action.getActionTypesAsArray()[which].toString().equals(Action_Enum.setBluetooth.toString())) + { + if(!getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH)) + Miscellaneous.messageBox("Bluetooth", getResources().getString(R.string.deviceDoesNotHaveBluetooth), ActivityManageSpecificRule.this).show();; + newAction.setAction(Action_Enum.setBluetooth); + getActionParameter1Dialog(ActivityManageSpecificRule.this).show(); + } + else if(Action.getActionTypesAsArray()[which].toString().equals(Action_Enum.setUsbTethering.toString())) + { + newAction.setAction(Action_Enum.setUsbTethering); + if(Build.VERSION.SDK_INT > Build.VERSION_CODES.GINGERBREAD_MR1) + Toast.makeText(context, context.getResources().getString(R.string.usbTetheringFailForAboveGingerbread), Toast.LENGTH_LONG).show(); + getActionParameter1Dialog(ActivityManageSpecificRule.this).show(); + } + else if(Action.getActionTypesAsArray()[which].toString().equals(Action_Enum.setWifiTethering.toString())) + { + newAction.setAction(Action_Enum.setWifiTethering); + getActionParameter1Dialog(ActivityManageSpecificRule.this).show(); + } + else if(Action.getActionTypesAsArray()[which].toString().equals(Action_Enum.setDisplayRotation.toString())) + { + newAction.setAction(Action_Enum.setDisplayRotation); + getActionParameter1Dialog(ActivityManageSpecificRule.this).show(); + } + else if(Action.getActionTypesAsArray()[which].toString().equals(Action_Enum.changeSoundProfile.toString())) + { + if(Profile.getProfileCollection().size() > 0) + { + newAction.setAction(Action_Enum.changeSoundProfile); + getActionSoundProfileDialog(context).show(); + } + else + Toast.makeText(context, getResources().getString(R.string.noProfilesCreateOneFirst), Toast.LENGTH_LONG).show(); + } + else if(Action.getActionTypesAsArray()[which].toString().equals(Action_Enum.startOtherActivity.toString())) + { + newAction.setAction(Action_Enum.startOtherActivity); + Intent intent = new Intent(ActivityManageSpecificRule.this, ActivityManageStartActivity.class); + startActivityForResult(intent, 3000); + } + else if(Action.getActionTypesAsArray()[which].toString().equals(Action_Enum.waitBeforeNextAction.toString())) + { + newAction.setAction(Action_Enum.waitBeforeNextAction); + getActionWaitBeforeNextActionDialog(ActivityManageSpecificRule.this).show(); + } + else if(Action.getActionTypesAsArray()[which].toString().equals(Action_Enum.wakeupDevice.toString())) + { + newAction.setAction(Action_Enum.wakeupDevice); + getActionWakeupDeviceDialog(ActivityManageSpecificRule.this).show(); + } + else if(Action.getActionTypesAsArray()[which].toString().equals(Action_Enum.setAirplaneMode.toString())) + { + if(Build.VERSION.SDK_INT >= 17) + { + Toast.makeText(context, getResources().getString(R.string.airplaneModeSdk17Warning), Toast.LENGTH_LONG).show(); + Miscellaneous.messageBox(getResources().getString(R.string.airplaneMode), getResources().getString(R.string.rootExplanation), ActivityManageSpecificRule.this).show(); + } + newAction.setAction(Action_Enum.setAirplaneMode); + getActionParameter1Dialog(ActivityManageSpecificRule.this).show(); + } + else if(Action.getActionTypesAsArray()[which].toString().equals(Action_Enum.setDataConnection.toString())) + { + newAction.setAction(Action_Enum.setDataConnection); + getActionParameter1Dialog(ActivityManageSpecificRule.this).show(); + Miscellaneous.messageBox(getResources().getString(R.string.actionDataConnection), getResources().getString(R.string.rootExplanation), ActivityManageSpecificRule.this).show(); + } + else if(Action.getActionTypesAsArray()[which].toString().equals(Action_Enum.speakText.toString())) + { + //launch other activity to enter a url and parameters; + newAction.setAction(Action_Enum.speakText); + ActivityEditSpeakText.resultingAction = null; + Intent editTriggerIntent = new Intent(context, ActivityEditSpeakText.class); + startActivityForResult(editTriggerIntent, 5000); + } + else if(Action.getActionTypesAsArray()[which].toString().equals(Action_Enum.sendTextMessage.toString())) + { +// if(ActivityPermissions.isPermissionDeclaratedInManifest(ActivityManageSpecificRule.this, "android.permission.SEND_SMS") && !Miscellaneous.isGooglePlayInstalled(ActivityManageSpecificRule.this)) + if(ActivityPermissions.isPermissionDeclaratedInManifest(ActivityManageSpecificRule.this, "android.permission.SEND_SMS")) + { + //launch other activity to enter parameters; + newAction.setAction(Action_Enum.sendTextMessage); + ActivityEditSendTextMessage.resultingAction = null; + Intent editTriggerIntent = new Intent(context, ActivityEditSendTextMessage.class); + startActivityForResult(editTriggerIntent, 5001); + } + } + else if(Action.getActionTypesAsArray()[which].toString().equals(Action_Enum.playMusic.toString())) + { + newAction.setAction(Action_Enum.playMusic); + ruleToEdit.getActionSet().add(newAction); + refreshActionList(); + } + else if(Action.getActionTypesAsArray()[which].toString().equals(Action_Enum.setScreenBrightness.toString())) + { + newAction.setAction(Action_Enum.setScreenBrightness); + Intent actionScreenBrightnessIntent = new Intent(context, ActivityManageBrightnessSetting.class); + startActivityForResult(actionScreenBrightnessIntent, requestCodeActionScreenBrightnessAdd); + } + } + }); + + return builder.create(); + } + private AlertDialog getActionSoundProfileDialog(final Context myContext) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(context); + alertDialogBuilder.setTitle(getResources().getString(R.string.selectSoundProfile)); + + final String[] choices; +// choices = new String[]{"silent", "vibrate", "normal"}; + ArrayList list = Profile.getProfileCollectionString(); + choices = list.toArray(new String[list.size()]); + + alertDialogBuilder.setItems(choices, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + newAction.setParameter2(choices[which]); + ruleToEdit.getActionSet().add(newAction); + refreshActionList(); + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + + private AlertDialog getTriggerDeleteDialog(Context myContext, final Trigger triggerToBeDeleted) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(context); + alertDialogBuilder.setTitle(getResources().getString(R.string.whatToDoWithTrigger)); + alertDialogBuilder.setItems(new String[]{getResources().getString(R.string.delete)}, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + // Only 1 choice at the moment, no need to check + ruleToEdit.getTriggerSet().remove(triggerToBeDeleted); + refreshTriggerList(); + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + private AlertDialog getActionDeleteDialog(Context myContext, final Action actionToBeDeleted) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(context); + alertDialogBuilder.setTitle(getResources().getString(R.string.whatToDoWithAction)); + alertDialogBuilder.setItems(new String[] { getResources().getString(R.string.delete), getResources().getString(R.string.moveUp), getResources().getString(R.string.moveDown)}, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + int positionOfSelected; + switch(which) + { + case 0: + // Delete + if(ruleToEdit.getActionSet().remove(actionToBeDeleted)) + { + refreshActionList(); + } + break; + case 1: + // Move up + positionOfSelected = ruleToEdit.getActionSet().indexOf(actionToBeDeleted); + if(positionOfSelected > 0) + { + Miscellaneous.logEvent("i", "Swap", "Swapping positions " + String.valueOf(positionOfSelected) + " and " + String.valueOf(positionOfSelected-1), 4); + Collections.swap(ruleToEdit.getActionSet(), positionOfSelected, positionOfSelected-1); + refreshActionList(); + } + else + { + // Is already at the top + Toast.makeText(ActivityManageSpecificRule.this, getResources().getString(R.string.cantMoveUp), Toast.LENGTH_LONG).show(); + } + break; + case 2: + // Move down + positionOfSelected = ruleToEdit.getActionSet().indexOf(actionToBeDeleted); + Miscellaneous.logEvent("i", "Swap", "Swapping positions " + String.valueOf(positionOfSelected) + " and " + String.valueOf(positionOfSelected+1), 4); + if(positionOfSelected < ruleToEdit.getActionSet().size()-1) + { + Collections.swap(ruleToEdit.getActionSet(), positionOfSelected, positionOfSelected+1); + refreshActionList(); + } + else + { + // Is already at the bottom + Toast.makeText(ActivityManageSpecificRule.this, getResources().getString(R.string.cantMoveDown), Toast.LENGTH_LONG).show(); + } + break; + } + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + + /*private AlertDialog getActionStartActivityDialog1(final Context myContext) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(context); + alertDialogBuilder.setTitle(myContext.getResources().getString(R.string.selectApplication)); + final String[] applicationArray = ActivityManageStartActivity.getApplicationNameListString(ActivityManageSpecificRule.this); + alertDialogBuilder.setItems(applicationArray, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + getActionStartActivityDialog2(myContext, applicationArray[which]).show(); + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + private AlertDialog getActionStartActivityDialog2(final Context myContext, String applicationName) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(context); + alertDialogBuilder.setTitle(myContext.getResources().getString(R.string.selectPackageOfApplication)); + final String[] packageArray = ActivityManageStartActivity.getPackageListString(ActivityManageSpecificRule.this, applicationName); + alertDialogBuilder.setItems(packageArray, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + getActionStartActivityDialog3(ActivityManageSpecificRule.this, packageArray[which]).show(); + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + private AlertDialog getActionStartActivityDialog3(final Context myContext, final String packageName) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(context); + alertDialogBuilder.setTitle(myContext.getResources().getString(R.string.selectActivityToBeStarted)); + final String activityArray[] = ActivityManageStartActivity.getActivityListForPackageName(packageName); + alertDialogBuilder.setItems(activityArray, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + ActivityInfo ai = ActivityManageStartActivity.getActivityInfoForPackageNameAndActivityName(packageName, activityArray[which]); +// Log.i("Selected", ai.packageName + " / " + ai.name); + newAction.setParameter2(ai.packageName + ";" + ai.name); + newAction.toString(); + ruleToEdit.getActionSet().add(newAction); + refreshActionList(); + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + }*/ + + private AlertDialog getActionWaitBeforeNextActionDialog(final Context myContext) + { + AlertDialog.Builder alertDialog = new AlertDialog.Builder(this); + + alertDialog.setTitle(myContext.getResources().getString(R.string.waitBeforeNextAction)); + alertDialog.setMessage(myContext.getResources().getString(R.string.waitBeforeNextActionEnterValue)); + + // Set an EditText view to get user input + final EditText input = new EditText(this); + input.setInputType(InputType.TYPE_CLASS_NUMBER); + alertDialog.setView(input); + + alertDialog.setPositiveButton("Ok", new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog, int whichButton) + { + if(input.getText().toString().length() == 0| input.getText().toString().equals("0") | input.getText().toString().contains(",") | input.getText().toString().contains(".")) + { + Toast.makeText(myContext, ActivityManageSpecificRule.this.getResources().getString(R.string.enterAPositiveValidNonDecimalNumber), Toast.LENGTH_LONG).show(); + getActionWaitBeforeNextActionDialog(ActivityManageSpecificRule.this).show(); + } + else + { + newAction.setParameter2(input.getText().toString()); + newAction.toString(); + ruleToEdit.getActionSet().add(newAction); + refreshActionList(); + } + } + }); + + alertDialog.setNegativeButton(myContext.getResources().getString(R.string.cancel), new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog, int whichButton) + { + // Canceled. + } + }); + + return alertDialog.create(); + } + + private AlertDialog getActionWakeupDeviceDialog(final Context myContext) + { + AlertDialog.Builder alertDialog = new AlertDialog.Builder(this); + + alertDialog.setTitle(myContext.getResources().getString(R.string.wakeupDevice)); + alertDialog.setMessage(myContext.getResources().getString(R.string.wakeupDeviceValue)); + + // Set an EditText view to get user input + final EditText input = new EditText(this); + input.setInputType(InputType.TYPE_CLASS_NUMBER); + alertDialog.setView(input); + + alertDialog.setPositiveButton("Ok", new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog, int whichButton) + { + if(input.getText().toString().length() == 0| input.getText().toString().contains(",") | input.getText().toString().contains(".")) + { + Toast.makeText(myContext, ActivityManageSpecificRule.this.getResources().getString(R.string.enterAPositiveValidNonDecimalNumber), Toast.LENGTH_LONG).show(); + getActionWakeupDeviceDialog(ActivityManageSpecificRule.this).show(); + } + else + { + newAction.setParameter2(input.getText().toString()); + newAction.toString(); + ruleToEdit.getActionSet().add(newAction); + refreshActionList(); + } + } + }); + + alertDialog.setNegativeButton(myContext.getResources().getString(R.string.cancel), new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog, int whichButton) + { + // Canceled. + } + }); + + return alertDialog.create(); + } + + private AlertDialog getActionParameter1Dialog(final Context myContext) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(context); + alertDialogBuilder.setTitle(myContext.getResources().getString(R.string.selectToggleDirection)); + final String choices[] = { myContext.getString(R.string.activate), myContext.getString(R.string.deactivate) }; + alertDialogBuilder.setItems(choices, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + if(which == 0) + newAction.setParameter1(true); + else + newAction.setParameter1(false); + + ruleToEdit.getActionSet().add(newAction); + refreshActionList(); + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + + protected void refreshTriggerList() + { + Miscellaneous.logEvent("i", "ListView", "Attempting to update TriggerListView", 4); + if(triggerListView.getAdapter() == null) + { + triggerListView.setAdapter(triggerListViewAdapter); + } + triggerListViewAdapter.notifyDataSetChanged(); + } + protected void refreshActionList() + { + Miscellaneous.logEvent("i", "ListView", "Attempting to update ActionListView", 4); + if(actionListView.getAdapter() == null) + { + actionListView.setAdapter(actionListViewAdapter); + } + actionListViewAdapter.notifyDataSetChanged(); + } + + public static class Item + { + public final String text; + public final int icon; + + public Item(String text, Integer icon) + { + this.text = text; + this.icon = icon; + } + + @Override + public String toString() { + return text; + } + } + + protected void hideKeyboard() + { + View view = this.getCurrentFocus(); + if (view != null) + { + InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); + imm.hideSoftInputFromWindow(view.getWindowToken(), 0); + } + } +} diff --git a/app/src/main/java/com/jens/automation2/ActivityManageStartActivity.java b/app/src/main/java/com/jens/automation2/ActivityManageStartActivity.java new file mode 100644 index 0000000..f7f29a3 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivityManageStartActivity.java @@ -0,0 +1,500 @@ +package com.jens.automation2; + +import android.app.Activity; +import android.app.AlertDialog; +import android.app.ProgressDialog; +import android.content.Context; +import android.content.DialogInterface; +import android.content.Intent; +import android.content.pm.ActivityInfo; +import android.content.pm.ApplicationInfo; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager; +import android.os.AsyncTask; +import android.os.Bundle; +import android.text.InputType; +import android.view.MotionEvent; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.View.OnTouchListener; +import android.widget.AdapterView; +import android.widget.AdapterView.OnItemLongClickListener; +import android.widget.AdapterView.OnItemSelectedListener; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.EditText; +import android.widget.ListView; +import android.widget.Spinner; +import android.widget.TextView; +import android.widget.Toast; + +import com.jens.automation2.Action.Action_Enum; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +public class ActivityManageStartActivity extends Activity +{ + ListView lvIntentPairs; + EditText etParameterName, etParameterValue; + Button bSelectApp, bAddIntentPair, bSaveActionStartOtherActivity; + Spinner spinnerParameterType; + TextView tvSelectedActivity; + boolean edit = false; + ProgressDialog progressDialog = null; + + private class CustomPackageInfo extends PackageInfo implements Comparable + { + @Override + public int compareTo(CustomPackageInfo another) + { + String name1 = ""; + String name2 = ""; + + ApplicationInfo aInfo1 = this.applicationInfo; + if (aInfo1 != null) + { + name1 = (String) ActivityManageStartActivity.this.getPackageManager().getApplicationLabel(aInfo1); + } + ApplicationInfo aInfo2 = another.applicationInfo; + if (aInfo2 != null) + { + name2 = (String) ActivityManageStartActivity.this.getPackageManager().getApplicationLabel(aInfo2); + } + + return name1.compareTo(name2); + } + + } + + private static List pInfos = null; + public static Action resultingAction; + + private static final String[] supportedIntentTypes = { "boolean", "byte", "char", "double", "float", "int", "long", "short", "String" }; + private ArrayList intentPairList = new ArrayList(); + + ArrayAdapter intentTypeSpinnerAdapter, intentPairAdapter; + + public static void getActivityList(final Context context) + { + if(pInfos == null) + { + pInfos = context.getPackageManager().getInstalledPackages(PackageManager.GET_ACTIVITIES); + Collections.sort(pInfos, new Comparator() + { + public int compare(PackageInfo obj1, PackageInfo obj2) + { + String name1 = ""; + String name2 = ""; + + ApplicationInfo aInfo1 = obj1.applicationInfo; + if (aInfo1 != null) + { + name1 = (String) context.getPackageManager().getApplicationLabel(aInfo1); + } + ApplicationInfo aInfo2 = obj2.applicationInfo; + if (aInfo2 != null) + { + name2 = (String) context.getPackageManager().getApplicationLabel(aInfo2); + } + + return name1.compareTo(name2); + } + }); + } + } + + public static String[] getApplicationNameListString(Context myContext) + { + // Generate the actual list + getActivityList(myContext); + + ArrayList returnList = new ArrayList(); + + for (PackageInfo pInfo : pInfos) + { + ApplicationInfo aInfo = pInfo.applicationInfo; + if (aInfo != null) + { + String aLabel; + + aLabel = (String) myContext.getPackageManager().getApplicationLabel(aInfo); + + ActivityInfo[] aInfos = pInfo.activities; + if (aInfos != null && aInfos.length > 0) // Only put Applications into the list that have packages. + { + if(!returnList.contains(aLabel)) + returnList.add(aLabel); + } + } + } + + return returnList.toArray(new String[returnList.size()]); + } + + public static String[] getPackageListString(Context myContext, String applicationLabel) + { + // Generate the actual list + getActivityList(myContext); + + ArrayList returnList = new ArrayList(); + + for (PackageInfo pInfo : pInfos) + { + if(myContext.getPackageManager().getApplicationLabel(pInfo.applicationInfo).equals(applicationLabel)) + { + ActivityInfo[] aInfos = pInfo.activities; + if (aInfos != null && aInfos.length > 0) + { + returnList.add(pInfo.packageName); + } + } + } + + return returnList.toArray(new String[returnList.size()]); + } + + public static String[] getPackageListString(Context myContext) + { + // Generate the actual list + getActivityList(myContext); + + ArrayList returnList = new ArrayList(); + + for (PackageInfo pInfo : pInfos) + { + ActivityInfo[] aInfos = pInfo.activities; + if (aInfos != null && aInfos.length > 0) + { + returnList.add(pInfo.packageName); + } + else + Miscellaneous.logEvent("w", "Empty Application", "Application " + myContext.getPackageManager().getApplicationLabel(pInfo.applicationInfo) + " doesn\'t have packages.", 5); + } + + return returnList.toArray(new String[returnList.size()]); + } + + public static String[] getActivityListForPackageName(String packageName) + { + ArrayList returnList = new ArrayList(); + + for (PackageInfo pInfo : pInfos) + { + if(pInfo.packageName.equals(packageName)) + { + ActivityInfo[] aInfos = pInfo.activities; + if (aInfos != null) + { + for (ActivityInfo activityInfo : aInfos) + { + returnList.add(activityInfo.name); + } + } + } + } + + return returnList.toArray(new String[returnList.size()]); + } + + public static ActivityInfo getActivityInfoForPackageNameAndActivityName(String packageName, String activityName) + { + for (PackageInfo pInfo : pInfos) + { + if(pInfo.packageName.equals(packageName)) + { + ActivityInfo[] aInfos = pInfo.activities; + if (aInfos != null) + { + for (ActivityInfo activityInfo : aInfos) + { + if(activityInfo.name.equals(activityName)) + return activityInfo; + } + } + } + } + + return null; + } + + private AlertDialog getActionStartActivityDialog1() + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this); + alertDialogBuilder.setTitle(getResources().getString(R.string.selectApplication)); + final String[] applicationArray = ActivityManageStartActivity.getApplicationNameListString(this); + alertDialogBuilder.setItems(applicationArray, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + dialog.dismiss(); + getActionStartActivityDialog2(applicationArray[which]).show(); + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + private AlertDialog getActionStartActivityDialog2(String applicationName) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this); + alertDialogBuilder.setTitle(getResources().getString(R.string.selectPackageOfApplication)); + final String[] packageArray = ActivityManageStartActivity.getPackageListString(this, applicationName); + alertDialogBuilder.setItems(packageArray, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + getActionStartActivityDialog3(packageArray[which]).show(); + Miscellaneous.messageBox(getResources().getString(R.string.hint), getResources().getString(R.string.chooseActivityHint), ActivityManageStartActivity.this).show(); + + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + private AlertDialog getActionStartActivityDialog3(final String packageName) + { + AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this); + alertDialogBuilder.setTitle(getResources().getString(R.string.selectActivityToBeStarted)); + final String activityArray[] = ActivityManageStartActivity.getActivityListForPackageName(packageName); + alertDialogBuilder.setItems(activityArray, new DialogInterface.OnClickListener() + { + @Override + public void onClick(DialogInterface dialog, int which) + { + ActivityInfo ai = ActivityManageStartActivity.getActivityInfoForPackageNameAndActivityName(packageName, activityArray[which]); + tvSelectedActivity.setText(ai.packageName + ";" + ai.name); + } + }); + AlertDialog alertDialog = alertDialogBuilder.create(); + + return alertDialog; + } + + @Override + protected void onCreate(Bundle savedInstanceState) + { + super.onCreate(savedInstanceState); + setContentView(R.layout.action_start_activity); + + lvIntentPairs = (ListView)findViewById(R.id.lvIntentPairs); + etParameterName = (EditText)findViewById(R.id.etParameterName); + etParameterValue = (EditText)findViewById(R.id.etParameterValue); + bSelectApp = (Button)findViewById(R.id.bSelectApp); + bAddIntentPair = (Button)findViewById(R.id.bAddIntentPair); + bSaveActionStartOtherActivity = (Button)findViewById(R.id.bSaveActionStartOtherActivity); + spinnerParameterType = (Spinner)findViewById(R.id.spinnerParameterType); + tvSelectedActivity = (TextView)findViewById(R.id.tvSelectedActivity); + + intentTypeSpinnerAdapter = new ArrayAdapter(this, R.layout.text_view_for_poi_listview_mediumtextsize, ActivityManageStartActivity.supportedIntentTypes); + spinnerParameterType.setAdapter(intentTypeSpinnerAdapter); + intentTypeSpinnerAdapter.notifyDataSetChanged(); + + intentPairAdapter = new ArrayAdapter(this, R.layout.text_view_for_poi_listview_smalltextsize, intentPairList); + + bSelectApp.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + GetActivityListTask getActivityListTask = new GetActivityListTask(); + getActivityListTask.execute(); + progressDialog = ProgressDialog.show(ActivityManageStartActivity.this, "", ActivityManageStartActivity.this.getResources().getString(R.string.gettingListOfInstalledApplications)); + } + }); + + bAddIntentPair.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + // type;name;value + if(spinnerParameterType.getSelectedItem().toString().length() == 0) + { + Toast.makeText(ActivityManageStartActivity.this, getResources().getString(R.string.selectTypeOfIntentPair), Toast.LENGTH_LONG).show(); + return; + } + + if(etParameterName.getText().toString().length() == 0) + { + Toast.makeText(ActivityManageStartActivity.this, getResources().getString(R.string.enterNameForIntentPair), Toast.LENGTH_LONG).show(); + return; + } + + if(etParameterValue.getText().toString().length() == 0) + { + Toast.makeText(ActivityManageStartActivity.this, getResources().getString(R.string.enterValueForIntentPair), Toast.LENGTH_LONG).show(); + return; + } + + String param = supportedIntentTypes[spinnerParameterType.getSelectedItemPosition()] + "/" + etParameterName.getText().toString() + "/" + etParameterValue.getText().toString(); + intentPairList.add(param); + + spinnerParameterType.setSelection(0); + etParameterName.setText(""); + etParameterValue.setText(""); + + updateIntentPairList(); + } + }); + + lvIntentPairs.setOnItemLongClickListener(new OnItemLongClickListener() + { + @Override + public boolean onItemLongClick(AdapterView arg0, View arg1, int arg2, long arg3) + { + getIntentPairDialog(arg2).show(); + return false; + } + }); + + bSaveActionStartOtherActivity.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + if(saveAction()) + { + ActivityManageStartActivity.this.setResult(RESULT_OK); + finish(); + } + } + }); + + lvIntentPairs.setOnTouchListener(new OnTouchListener() + { + @Override + public boolean onTouch(View v, MotionEvent event) + { + v.getParent().requestDisallowInterceptTouchEvent(true); + return false; + } + }); + + spinnerParameterType.setOnItemSelectedListener(new OnItemSelectedListener() + { + @Override + public void onItemSelected(AdapterView arg0, View arg1, int arg2, long arg3) + { + if(supportedIntentTypes[arg2].equals("double") | supportedIntentTypes[arg2].equals("float") | supportedIntentTypes[arg2].equals("int") | supportedIntentTypes[arg2].equals("long") | supportedIntentTypes[arg2].equals("short")) + ActivityManageStartActivity.this.etParameterValue.setInputType(InputType.TYPE_CLASS_NUMBER); + else + ActivityManageStartActivity.this.etParameterValue.setInputType(InputType.TYPE_CLASS_TEXT); + } + + @Override + public void onNothingSelected(AdapterView arg0) + { + // TODO Auto-generated method stub + + } + }); + + Intent i = getIntent(); + if(i.getBooleanExtra("edit", false) == true) + { + edit = true; + loadValuesIntoGui(); + } + } + + private void loadValuesIntoGui() + { + String[] params = resultingAction.getParameter2().split(";"); + if(params.length >= 2) + { + tvSelectedActivity.setText(params[0] + ";" + params[1]); + + if(params.length > 2) + { + intentPairList.clear(); + + for(int i=2; i + { + @Override + protected Void doInBackground(Void... params) + { + getActivityList(ActivityManageStartActivity.this); + return null; + } + + @Override + protected void onPostExecute(Void result) + { + progressDialog.dismiss(); + getActionStartActivityDialog1().show(); + } + + + } +} diff --git a/app/src/main/java/com/jens/automation2/ActivityManageTimeFrame.java b/app/src/main/java/com/jens/automation2/ActivityManageTimeFrame.java new file mode 100644 index 0000000..b6c8320 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivityManageTimeFrame.java @@ -0,0 +1,163 @@ +package com.jens.automation2; + +import android.app.Activity; +import android.os.Bundle; +import android.view.View; +import android.view.View.OnClickListener; +import android.widget.Button; +import android.widget.CheckBox; +import android.widget.RadioButton; +import android.widget.TimePicker; +import android.widget.Toast; + +import java.sql.Time; +import java.util.ArrayList; +import java.util.Calendar; + +public class ActivityManageTimeFrame extends Activity +{ + Button bSaveTimeFrame; + TimePicker startPicker, stopPicker; + CheckBox checkMonday, checkTuesday, checkWednesday, checkThursday, checkFriday, checkSaturday, checkSunday; + RadioButton radioTimeFrameEntering, radioTimeFrameLeaving; + + public static Trigger editedTimeFrameTrigger = null; + + @Override + protected void onCreate(Bundle savedInstanceState) + { + super.onCreate(savedInstanceState); + setContentView(R.layout.trigger_timeframe_editor); + + startPicker = (TimePicker)findViewById(R.id.tpTimeFrameStart); + stopPicker = (TimePicker)findViewById(R.id.tpTimeFrameStop); + startPicker.setIs24HourView(true); + stopPicker.setIs24HourView(true); + + bSaveTimeFrame = (Button)findViewById(R.id.bSaveTimeFrame); + checkMonday = (CheckBox)findViewById(R.id.checkMonday); + checkTuesday = (CheckBox)findViewById(R.id.checkTuesday); + checkWednesday = (CheckBox)findViewById(R.id.checkWednesday); + checkThursday = (CheckBox)findViewById(R.id.checkThursday); + checkFriday = (CheckBox)findViewById(R.id.checkFriday); + checkSaturday = (CheckBox)findViewById(R.id.checkSaturday); + checkSunday = (CheckBox)findViewById(R.id.checkSunday); + radioTimeFrameEntering = (RadioButton)findViewById(R.id.radioTimeFrameEntering); + radioTimeFrameLeaving = (RadioButton)findViewById(R.id.radioTimeFrameLeaving); + + bSaveTimeFrame.setOnClickListener(new OnClickListener() + { + @Override + public void onClick(View v) + { + Time startTime = new Time(0); + startTime.setHours(startPicker.getCurrentHour()); + startTime.setMinutes(startPicker.getCurrentMinute()); + + Time stopTime = new Time(0); + stopTime.setHours(stopPicker.getCurrentHour()); + stopTime.setMinutes(stopPicker.getCurrentMinute()); + + ArrayList dayList = new ArrayList(); + if(checkMonday.isChecked()) + dayList.add(Calendar.MONDAY); + if(checkTuesday.isChecked()) + dayList.add(Calendar.TUESDAY); + if(checkWednesday.isChecked()) + dayList.add(Calendar.WEDNESDAY); + if(checkThursday.isChecked()) + dayList.add(Calendar.THURSDAY); + if(checkFriday.isChecked()) + dayList.add(Calendar.FRIDAY); + if(checkSaturday.isChecked()) + dayList.add(Calendar.SATURDAY); + if(checkSunday.isChecked()) + dayList.add(Calendar.SUNDAY); + + if( + !checkMonday.isChecked() + && + !checkTuesday.isChecked() + && + !checkWednesday.isChecked() + && + !checkThursday.isChecked() + && + !checkFriday.isChecked() + && + !checkSaturday.isChecked() + && + !checkSunday.isChecked() + ) + { + Toast.makeText(getBaseContext(), getResources().getString(R.string.selectOneDay), Toast.LENGTH_LONG).show(); + return; + } + + if(editedTimeFrameTrigger.getTimeFrame() == null) + // add new one + editedTimeFrameTrigger.setTimeFrame(new TimeFrame(startTime, stopTime, dayList)); + else + { + // edit one + editedTimeFrameTrigger.getTimeFrame().setTriggerTimeStart(startTime); + editedTimeFrameTrigger.getTimeFrame().setTriggerTimeStop(stopTime); + editedTimeFrameTrigger.getTimeFrame().getDayList().clear(); + editedTimeFrameTrigger.getTimeFrame().setDayList(dayList); + } + + editedTimeFrameTrigger.setTriggerParameter(radioTimeFrameEntering.isChecked()); + + setResult(RESULT_OK); + finish(); + } + }); + + if(editedTimeFrameTrigger.getTimeFrame() != null) + loadVariableIntoGui(); + } + + private void loadVariableIntoGui() + { + startPicker.setCurrentHour(editedTimeFrameTrigger.getTimeFrame().getTriggerTimeStart().getHours()); + startPicker.setCurrentMinute(editedTimeFrameTrigger.getTimeFrame().getTriggerTimeStart().getMinutes()); + + stopPicker.setCurrentHour(editedTimeFrameTrigger.getTimeFrame().getTriggerTimeStop().getHours()); + stopPicker.setCurrentMinute(editedTimeFrameTrigger.getTimeFrame().getTriggerTimeStop().getMinutes()); + + radioTimeFrameEntering.setChecked(editedTimeFrameTrigger.getTriggerParameter()); + radioTimeFrameLeaving.setChecked(!editedTimeFrameTrigger.getTriggerParameter()); + + for(int day : editedTimeFrameTrigger.getTimeFrame().getDayList()) + { + switch(day) + { + case Calendar.MONDAY: + checkMonday.setChecked(true); + break; + case Calendar.TUESDAY: + checkTuesday.setChecked(true); + break; + case Calendar.WEDNESDAY: + checkWednesday.setChecked(true); + break; + case Calendar.THURSDAY: + checkThursday.setChecked(true); + break; + case Calendar.FRIDAY: + checkFriday.setChecked(true); + break; + case Calendar.SATURDAY: + checkSaturday.setChecked(true); + break; + case Calendar.SUNDAY: + checkSunday.setChecked(true); + break; + default: + Miscellaneous.logEvent("w", "TimeFrame", "Daylist contains invalid day: " + String.valueOf(day), 4); + break; + } + } + } + +} diff --git a/app/src/main/java/com/jens/automation2/ActivityPermissions.java b/app/src/main/java/com/jens/automation2/ActivityPermissions.java new file mode 100644 index 0000000..d509ba2 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivityPermissions.java @@ -0,0 +1,1370 @@ +package com.jens.automation2; + +import android.app.Activity; +import android.app.NotificationManager; +import android.content.Context; +import android.content.Intent; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager; +import android.net.Uri; +import android.os.Build; +import android.os.Bundle; +import android.text.Html; +import android.util.Log; +import android.view.View; +import android.widget.Button; +import android.widget.TextView; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +public class ActivityPermissions extends Activity +{ + static Map mapGeneralPermissions = null; + static Map mapTriggerPermissions = null; + static Map mapActionPermissions = null; + + public static final int notificationIdPermissions = 1001; + + public static final int requestCodeForPermissions = 12042; + private static final int requestCodeForPermissionsWriteSettings = 12043; + private static final int requestCodeForPermissionsNotificationPolicy = 12044; + protected String[] specificPermissionsToRequest = null; + + public static String intentExtraName = "permissionsToBeRequested"; + + Button bCancelPermissions, bRequestPermissions; + TextView tvPermissionsExplanation, tvPermissionosExplanationSystemSettings, tvPermissionsExplanationLong; + static ActivityPermissions instance = null; + + public static final String writeSystemSettingsPermissionName = "android.permission.WRITE_SETTINGS"; + public static final String writeExternalStoragePermissionName = "android.permission.WRITE_EXTERNAL_STORAGE"; + public static final String accessNotificationPolicyPermissionName = "android.permission.ACCESS_NOTIFICATION_POLICY"; + public static final String permissionNameLocationFine = "android.permission.ACCESS_FINE_LOCATION"; + public static final String permissionNameLocationCoarse = "android.permission.ACCESS_COARSE_LOCATION"; + public static final String permissionNameLocationBackground = "android.permission.ACCESS_BACKGROUND_LOCATION"; + public static final String permissionNameCall = "android.permission.PROCESS_OUTGOING_CALLS"; + public static final String permissionNameStartService = "android.permission.FOREGROUND_SERVICE"; + + public static ActivityPermissions getInstance() + { + if(instance == null) + instance = new ActivityPermissions(); + + return instance; + } + + @Override + protected void onCreate(Bundle savedInstanceState) + { + instance = this; + + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) + { + super.onCreate(savedInstanceState); + setContentView(R.layout.permissions_activity); + + bCancelPermissions = (Button)findViewById(R.id.bCancelPermissions); + bRequestPermissions = (Button)findViewById(R.id.bRequestPermissions); + tvPermissionsExplanation = (TextView)findViewById(R.id.tvPermissionsExplanation); + tvPermissionosExplanationSystemSettings = (TextView)findViewById(R.id.tvPermissionsExplanationSystemSettings); + tvPermissionsExplanationLong = (TextView)findViewById(R.id.tvPermissionsExplanationLong); + + bCancelPermissions.setOnClickListener(new View.OnClickListener() + { + @Override + public void onClick(View v) + { + finish(); + } + }); + + bRequestPermissions.setOnClickListener(new View.OnClickListener() + { + @Override + public void onClick(View v) + { + finish(); + } + }); + bRequestPermissions.setOnClickListener(new View.OnClickListener() + { + @Override + public void onClick(View v) + { + // Request the basic permissions, that are absolutely required. + //getRequiredPermissions(true); // request permissions to access sd card access and "receive boot completed" + + //fillPermissionMaps(); + + + if(specificPermissionsToRequest != null) + requestSpecificPermission(specificPermissionsToRequest); + else + { + ArrayList list = new ArrayList(); + for(String s : getRequiredPermissions(false)) + list.add(s); + requestPermissions(list, false); // request all other permissions, based on the rules setup + } + } + }); + + if(savedInstanceState == null) + { + Bundle extras = getIntent().getExtras(); + if(extras != null) + { + specificPermissionsToRequest = extras.getStringArray(ActivityPermissions.intentExtraName);; +// requestSpecificPermission(permissionsToRequest); + tvPermissionsExplanationLong.setText(R.string.permissionsExplanationSmall); + tvPermissionsExplanation.setText(""); + fillExplanationText(); + return; + } + } + + // Don't have to request specific permissions, so search for generally remaining ones. + if(needMorePermissions(ActivityPermissions.this)) + { + fillExplanationText(); + } + else + { + setHaveAllPermissions(); + finish(); + } + } + else + finish(); + } + + protected void fillExplanationText() + { + StringBuilder explanation = new StringBuilder(); + String[] requiredPerms; + if(specificPermissionsToRequest != null) + requiredPerms = specificPermissionsToRequest; + else + requiredPerms = getRequiredPermissions(false); + + boolean locationPermissionExplained = false; + + for(String s : requiredPerms) + { + /* + Filter location permission and only name it once + */ + if(s.equals(permissionNameLocationCoarse) | s.equals(permissionNameLocationFine)) + { + if(!locationPermissionExplained) + { + explanation.append( + + "
" + + + + "" + + getResources().getString(R.string.readLocation) + + "" + + + "
" + ); + + for (String reason : getReasonForPermission(s)) + explanation.append(reason + "
"); + + locationPermissionExplained = true; + } + } + else + { + explanation.append( + + "
" + + + + "" + + getResources().getString(getResources().getIdentifier(s, "string", getPackageName())) + + "" + + + "
"); + + for (String reason : getReasonForPermission(s)) + explanation.append(reason + "
"); + } + } + + tvPermissionsExplanation.setText(Html.fromHtml(explanation.toString())); + + for(String s : requiredPerms) + { + if (s.equalsIgnoreCase(writeSystemSettingsPermissionName)) + { + if (requiredPerms.length == 1) + tvPermissionosExplanationSystemSettings.setText(getResources().getString(R.string.systemSettingsNote1)); + else if (requiredPerms.length > 1) + tvPermissionosExplanationSystemSettings.setText(getResources().getString(R.string.systemSettingsNote1) + getResources().getString(R.string.systemSettingsNote2)); + + break; + } + } + + ActivityMainScreen.updateMainScreen(); + } + + protected static void addToArrayListUnique(String value, ArrayList list) + { + if (!list.contains(value)) + list.add(value); + } + + public static boolean needMorePermissions(Context context) + { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) + { + for (String s : getRequiredPermissions(false)) + { + if (!havePermission(s, context)) + return true; + } + } + + return false; + } + + public static boolean havePermission(String s, Context context) + { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) + { + if(s.equals(writeSystemSettingsPermissionName)) + return android.provider.Settings.System.canWrite(context); + else if (s.equals(accessNotificationPolicyPermissionName)) + { + if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) + { + NotificationManager mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE); + return mNotificationManager.isNotificationPolicyAccessGranted(); + } + else + return true; + } + else + { + int res = context.checkCallingOrSelfPermission(s); + return (res == PackageManager.PERMISSION_GRANTED); + } + } + else + return true; + } + + public static String[] getRequiredPermissions(boolean onlyGeneral) + { + ArrayList requiredPermissions = new ArrayList(); + + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) + { +// Toast.makeText(Miscellaneous.getAnyContext(), "Checking permissions.", Toast.LENGTH_LONG).show(); + + Context workingContext = Miscellaneous.getAnyContext(); + + // We do not need to ask for RECEIVE_BOOT_COMPLETED permission. It is always granted. + /* + if(!havePermission("android.permission.RECEIVE_BOOT_COMPLETED", workingContext)) + addToArrayListUnique("android.permission.RECEIVE_BOOT_COMPLETED", requiredPermissions); + */ + + if (!havePermission("android.permission.WRITE_EXTERNAL_STORAGE", workingContext)) + addToArrayListUnique("android.permission.WRITE_EXTERNAL_STORAGE", requiredPermissions); + + for(Profile profile : Profile.getProfileCollection()) + { + if(profile.changeIncomingCallsRingtone) + { + addToArrayListUnique("android.permission.WRITE_SETTINGS", requiredPermissions); + } + } + + if (!onlyGeneral) + { + for (Rule rule : Rule.getRuleCollection()) + { + for (String singlePermission : getPermissionsForRule(rule)) + if (!havePermission(singlePermission, workingContext)) + addToArrayListUnique(singlePermission, requiredPermissions); + } + } + + /* + Not all permissions need to be asked for. + */ + + /*if(shouldShowRequestPermissionRationale("android.permission.RECORD_AUDIO")) + Toast.makeText(ActivityMainScreen.this, "shouldShowRequestPermissionRationale", Toast.LENGTH_LONG).show(); + else + Toast.makeText(ActivityMainScreen.this, "not shouldShowRequestPermissionRationale", Toast.LENGTH_LONG).show();*/ + +// addToArrayListUnique("Manifest.permission.RECORD_AUDIO", requiredPermissions); + /*int hasPermission = checkSelfPermission(Manifest.permission.RECORD_AUDIO); + if (hasPermission == PackageManager.PERMISSION_DENIED) + { + Toast.makeText(ActivityMainScreen.this, "Don't have record_audio. Requesting...", Toast.LENGTH_LONG).show(); +// requestPermissions(new String[]{"Manifest.permission.CAMERA"}, requestCodeForPermissions); + ActivityCompat.requestPermissions(ActivityMainScreen.this, new String[]{"Manifest.permission.CAMERA"}, requestCodeForPermissions); + } + else + Toast.makeText(ActivityMainScreen.this, "Have record_audio.", Toast.LENGTH_LONG).show();*/ + + } + + return requiredPermissions.toArray(new String[requiredPermissions.size()]); + } + + public static boolean havePermissionsForRule(Rule rule, Context context) + { + for(String perm : getPermissionsForRule(rule)) + { + if(!havePermission(perm, context)) + return false; + } + + return true; + } + + protected static ArrayList getPermissionsForRule(Rule rule) + { + ArrayList requiredPermissions = new ArrayList<>(); + + if (rule.isRuleActive()) + { + for (Trigger trigger : rule.getTriggerSet()) + { + switch (trigger.getTriggerType()) + { + case activityDetection: + addToArrayListUnique("com.google.android.gms.permission.ACTIVITY_RECOGNITION", requiredPermissions); + addToArrayListUnique("android.permission.ACTIVITY_RECOGNITION", requiredPermissions); + break; + case airplaneMode: + addToArrayListUnique("android.permission.ACCESS_NETWORK_STATE", requiredPermissions); + break; + case batteryLevel: + addToArrayListUnique("android.permission.READ_PHONE_STATE", requiredPermissions); +// addToArrayListUnique("android.permission.BATTERY_STATS", requiredPermissions); + break; + case bluetoothConnection: + addToArrayListUnique("android.permission.BLUETOOTH_ADMIN", requiredPermissions); + addToArrayListUnique("android.permission.BLUETOOTH", requiredPermissions); + addToArrayListUnique("android.permission.ACCESS_NETWORK_STATE", requiredPermissions); + break; + case charging: + addToArrayListUnique("android.permission.READ_PHONE_STATE", requiredPermissions); +// addToArrayListUnique("android.permission.BATTERY_STATS", requiredPermissions); + break; + case headsetPlugged: + addToArrayListUnique("android.permission.READ_PHONE_STATE", requiredPermissions); + break; + case nfcTag: + addToArrayListUnique("android.permission.NFC", requiredPermissions); + break; + case noiseLevel: + addToArrayListUnique("android.permission.RECORD_AUDIO", requiredPermissions); + break; + case phoneCall: + addToArrayListUnique("android.permission.READ_PHONE_STATE", requiredPermissions); + addToArrayListUnique(permissionNameCall, requiredPermissions); + break; + case pointOfInterest: + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) + { + addToArrayListUnique(permissionNameLocationBackground, requiredPermissions); + addToArrayListUnique(permissionNameLocationFine, requiredPermissions); + addToArrayListUnique(permissionNameLocationCoarse, requiredPermissions); + } + else + { + addToArrayListUnique(permissionNameLocationFine, requiredPermissions); + addToArrayListUnique(permissionNameLocationCoarse, requiredPermissions); + } + addToArrayListUnique("android.permission.ACCESS_NETWORK_STATE", requiredPermissions); + addToArrayListUnique("android.permission.INTERNET", requiredPermissions); + addToArrayListUnique("android.permission.ACCESS_WIFI_STATE", requiredPermissions); + break; + case process_started_stopped: + addToArrayListUnique("android.permission.GET_TASKS", requiredPermissions); + break; + case roaming: + addToArrayListUnique("android.permission.ACCESS_NETWORK_STATE", requiredPermissions); + break; + case speed: + addToArrayListUnique(permissionNameLocationFine, requiredPermissions); + addToArrayListUnique(permissionNameLocationCoarse, requiredPermissions); + if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) + addToArrayListUnique(permissionNameLocationBackground, requiredPermissions); + addToArrayListUnique("android.permission.ACCESS_NETWORK_STATE", requiredPermissions); + addToArrayListUnique("android.permission.INTERNET", requiredPermissions); + break; + case timeFrame: + break; + case usb_host_connection: + addToArrayListUnique("android.permission.READ_PHONE_STATE", requiredPermissions); +// addToArrayListUnique("android.permission.BATTERY_STATS", requiredPermissions); + break; + case wifiConnection: + addToArrayListUnique("android.permission.ACCESS_NETWORK_STATE", requiredPermissions); + addToArrayListUnique("android.permission.ACCESS_WIFI_STATE", requiredPermissions); + break; + default: + break; + } + } + + for (Action action : rule.getActionSet()) + { + switch (action.getAction()) + { + case changeSoundProfile: + addToArrayListUnique("android.permission.MODIFY_AUDIO_SETTINGS", requiredPermissions); + if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) + addToArrayListUnique(accessNotificationPolicyPermissionName, requiredPermissions); + break; + case disableScreenRotation: + addToArrayListUnique(writeSystemSettingsPermissionName, requiredPermissions); + break; + case enableScreenRotation: + addToArrayListUnique(writeSystemSettingsPermissionName, requiredPermissions); + break; + case playMusic: + break; + case sendTextMessage: + addToArrayListUnique("android.permission.SEND_SMS", requiredPermissions); + break; + case setAirplaneMode: + addToArrayListUnique(writeSystemSettingsPermissionName, requiredPermissions); + addToArrayListUnique("android.permission.ACCESS_NETWORK_STATE", requiredPermissions); + addToArrayListUnique("android.permission.ACCESS_SUPERUSER", requiredPermissions); + addToArrayListUnique("android.permission.CHANGE_NETWORK_STATE", requiredPermissions); + break; + case setBluetooth: + addToArrayListUnique("android.permission.BLUETOOTH_ADMIN", requiredPermissions); + addToArrayListUnique("android.permission.BLUETOOTH", requiredPermissions); + addToArrayListUnique("android.permission.ACCESS_NETWORK_STATE", requiredPermissions); + addToArrayListUnique(writeSystemSettingsPermissionName, requiredPermissions); + break; + case setDataConnection: + addToArrayListUnique(writeSystemSettingsPermissionName, requiredPermissions); + addToArrayListUnique("android.permission.ACCESS_NETWORK_STATE", requiredPermissions); + addToArrayListUnique("android.permission.ACCESS_SUPERUSER", requiredPermissions); + addToArrayListUnique("android.permission.CHANGE_NETWORK_STATE", requiredPermissions); + break; + case setDisplayRotation: + addToArrayListUnique(writeSystemSettingsPermissionName, requiredPermissions); + break; + case setUsbTethering: + addToArrayListUnique(writeSystemSettingsPermissionName, requiredPermissions); + addToArrayListUnique("android.permission.CHANGE_NETWORK_STATE", requiredPermissions); + break; + case setWifi: + addToArrayListUnique(writeSystemSettingsPermissionName, requiredPermissions); + addToArrayListUnique("android.permission.CHANGE_NETWORK_STATE", requiredPermissions); + addToArrayListUnique("android.permission.ACCESS_NETWORK_STATE", requiredPermissions); + break; + case setWifiTethering: + addToArrayListUnique(writeSystemSettingsPermissionName, requiredPermissions); + addToArrayListUnique("android.permission.CHANGE_NETWORK_STATE", requiredPermissions); + addToArrayListUnique("android.permission.ACCESS_NETWORK_STATE", requiredPermissions); + break; + case speakText: + break; + case startOtherActivity: + break; + case triggerUrl: + addToArrayListUnique("android.permission.INTERNET", requiredPermissions); + // Hier m��te ein Hinweis kommen, da� nur die Variablen verwendet werden k�nnen, f�r die es Rechte gibt. + break; + case turnBluetoothOff: + addToArrayListUnique("android.permission.BLUETOOTH_ADMIN", requiredPermissions); + addToArrayListUnique(writeSystemSettingsPermissionName, requiredPermissions); + addToArrayListUnique("android.permission.BLUETOOTH", requiredPermissions); + addToArrayListUnique("android.permission.ACCESS_NETWORK_STATE", requiredPermissions); + break; + case turnBluetoothOn: + addToArrayListUnique("android.permission.BLUETOOTH_ADMIN", requiredPermissions); + addToArrayListUnique(writeSystemSettingsPermissionName, requiredPermissions); + addToArrayListUnique("android.permission.BLUETOOTH", requiredPermissions); + addToArrayListUnique("android.permission.ACCESS_NETWORK_STATE", requiredPermissions); + break; + case turnUsbTetheringOff: + addToArrayListUnique(writeSystemSettingsPermissionName, requiredPermissions); + addToArrayListUnique("android.permission.CHANGE_NETWORK_STATE", requiredPermissions); + break; + case turnUsbTetheringOn: + addToArrayListUnique(writeSystemSettingsPermissionName, requiredPermissions); + addToArrayListUnique("android.permission.CHANGE_NETWORK_STATE", requiredPermissions); + break; + case turnWifiOff: + addToArrayListUnique(writeSystemSettingsPermissionName, requiredPermissions); + addToArrayListUnique("android.permission.CHANGE_NETWORK_STATE", requiredPermissions); + addToArrayListUnique("android.permission.ACCESS_NETWORK_STATE", requiredPermissions); + break; + case turnWifiOn: + addToArrayListUnique(writeSystemSettingsPermissionName, requiredPermissions); + addToArrayListUnique("android.permission.CHANGE_NETWORK_STATE", requiredPermissions); + addToArrayListUnique("android.permission.ACCESS_NETWORK_STATE", requiredPermissions); + break; + case turnWifiTetheringOff: + addToArrayListUnique(writeSystemSettingsPermissionName, requiredPermissions); + addToArrayListUnique("android.permission.CHANGE_NETWORK_STATE", requiredPermissions); + addToArrayListUnique("android.permission.ACCESS_NETWORK_STATE", requiredPermissions); + break; + case turnWifiTetheringOn: + addToArrayListUnique(writeSystemSettingsPermissionName, requiredPermissions); + addToArrayListUnique("android.permission.CHANGE_NETWORK_STATE", requiredPermissions); + addToArrayListUnique("android.permission.ACCESS_NETWORK_STATE", requiredPermissions); + break; + case waitBeforeNextAction: + break; + case wakeupDevice: + addToArrayListUnique("android.permission.WAKE_LOCK", requiredPermissions); + break; + default: + break; + + } + } + } + + return requiredPermissions; + } + + protected ArrayList getRulesUsing(Trigger.Trigger_Enum triggerType) + { + ArrayList returnList = new ArrayList<>(); + + for (Rule rule : Rule.getRuleCollection()) + { + if (rule.isRuleActive()) + { + for (Trigger trigger : rule.getTriggerSet()) + { + if(trigger.getTriggerType().equals(triggerType)) + addToArrayListUnique(rule.getName(), returnList); + } + } + } + + return returnList; + } + + protected ArrayList getRulesUsing(Action.Action_Enum actionType) + { + ArrayList returnList = new ArrayList<>(); + + for (Rule rule : Rule.getRuleCollection()) + { + if (rule.isRuleActive()) + { + for (Action action : rule.getActionSet()) + { + if(action.equals(actionType)) + addToArrayListUnique(rule.getName(), returnList); + } + } + } + + return returnList; + } + + public ArrayList getReasonForPermission(String permission) + { + ArrayList usingElements = new ArrayList(); + + switch(permission) + { + case "android.permission.RECEIVE_BOOT_COMPLETED": + usingElements.add(getResources().getString(R.string.startAtSystemBoot)); + break; + case accessNotificationPolicyPermissionName: + usingElements.add(getResources().getString(R.string.actionChangeSoundProfile)); + break; + case "android.permission.WRITE_EXTERNAL_STORAGE": + usingElements.add(getResources().getString(R.string.storeSettings)); + break; + case "com.google.android.gms.permission.ACTIVITY_RECOGNITION": + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.activityDetection)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + + break; + case "android.permission.ACTIVITY_RECOGNITION": + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.activityDetection)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + + break; + case permissionNameLocationCoarse: +// usingElements.add(getResources().getString(R.string.android_permission_ACCESS_COARSE_LOCATION)); + usingElements.add(getResources().getString(R.string.manageLocations)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.pointOfInterest)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.speed)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + break; + case permissionNameLocationFine: + usingElements.add(getResources().getString(R.string.manageLocations)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.pointOfInterest)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.speed)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + break; + case permissionNameLocationBackground: + usingElements.add(getResources().getString(R.string.googleLocationChicanery)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.pointOfInterest)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.speed)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + break; + case "android.permission.ACCESS_NETWORK_STATE": + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.airplaneMode)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.bluetoothConnection)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.pointOfInterest)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.roaming)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.speed)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.wifiConnection)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Action.Action_Enum.setAirplaneMode)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Action.Action_Enum.setBluetooth)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Action.Action_Enum.setDataConnection)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Action.Action_Enum.setWifi)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Action.Action_Enum.setWifiTethering)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Action.Action_Enum.turnBluetoothOff)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Action.Action_Enum.turnBluetoothOn)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Action.Action_Enum.turnWifiOff)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Action.Action_Enum.turnWifiOn)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Action.Action_Enum.turnWifiTetheringOff)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Action.Action_Enum.turnWifiTetheringOn)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + break; + case "android.permission.ACCESS_WIFI_STATE": + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.pointOfInterest)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.wifiConnection)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + break; + /*case "android.permission.BATTERY_STATS": + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.batteryLevel)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.charging)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.usb_host_connection)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + break;*/ + case "android.permission.BLUETOOTH_ADMIN": + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.bluetoothConnection)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Action.Action_Enum.setBluetooth)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Action.Action_Enum.turnBluetoothOff)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Action.Action_Enum.turnBluetoothOn)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + break; + case "android.permission.BLUETOOTH": + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.bluetoothConnection)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Action.Action_Enum.setBluetooth)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Action.Action_Enum.turnBluetoothOff)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Action.Action_Enum.turnBluetoothOn)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + break; + case "android.permission.GET_TASKS": + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.process_started_stopped)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + break; + case "android.permission.INTERNET": + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.pointOfInterest)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.speed)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Action.Action_Enum.triggerUrl)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + break; + case "android.permission.NFC": + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.nfcTag)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + break; + case permissionNameCall: + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.phoneCall)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + break; + case "android.permission.READ_PHONE_STATE": + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.batteryLevel)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.charging)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.headsetPlugged)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.phoneCall)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.usb_host_connection)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + break; + case "android.permission.RECORD_AUDIO": + for(String ruleName : getRulesUsing(Trigger.Trigger_Enum.noiseLevel)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + break; + case "android.permission.SEND_SMS": + for(String ruleName : getRulesUsing(Action.Action_Enum.sendTextMessage)) + usingElements.add(String.format(getResources().getString(R.string.ruleXrequiresThis), ruleName)); + break; + case "android.permission.FOREGROUND_SERVICE": + usingElements.add(getResources().getString(R.string.startAutomationAsService)); + break; + } + + return usingElements; + } + + @Override + protected void onActivityResult(int requestCode, int resultCode, Intent data) + { + super.onActivityResult(requestCode, resultCode, data); + + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) + { + if (requestCode == requestCodeForPermissionsWriteSettings) + if(android.provider.Settings.System.canWrite(ActivityPermissions.this)) + requestPermissions(cachedPermissionsToRequest, true); + + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) + { + if (requestCode == requestCodeForPermissionsNotificationPolicy) + { + NotificationManager mNotificationManager = (NotificationManager) ActivityPermissions.this.getSystemService(Context.NOTIFICATION_SERVICE); + + if (mNotificationManager.isNotificationPolicyAccessGranted()) + requestPermissions(cachedPermissionsToRequest, true); + } + } + + } + } + + public static void requestSpecificPermission(String... permissionNames) + { + ArrayList permissionList = new ArrayList(); + for(String permission : permissionNames) + { + if(permissionNames.equals(permissionNameCall)) + { + if(ActivityPermissions.isPermissionDeclaratedInManifest(Miscellaneous.getAnyContext(), permissionNameCall) && !Miscellaneous.isGooglePlayInstalled(Miscellaneous.getAnyContext())) + { + permissionList.add(permission); + } + } + else if(permissionNames.equals("android.permission.SEND_SMS")) + { + if(ActivityPermissions.isPermissionDeclaratedInManifest(Miscellaneous.getAnyContext(), "android.permission.SEND_SMS") && !Miscellaneous.isGooglePlayInstalled(Miscellaneous.getAnyContext())) + { + permissionList.add(permission); + } + } + else + { + if(!havePermission(permission, Miscellaneous.getAnyContext())) + permissionList.add(permission); + } + } + + getInstance().requestPermissions(permissionList, true); + } + + ArrayList cachedPermissionsToRequest = null; + protected void requestPermissions(ArrayList requiredPermissions, boolean continueWithRemainingPermissions) + { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) + { + if(!continueWithRemainingPermissions) + { + for (String s : requiredPermissions) + { + if (s.equalsIgnoreCase(writeSystemSettingsPermissionName)) + { + requiredPermissions.remove(s); + cachedPermissionsToRequest = requiredPermissions; + Intent intent = new Intent(android.provider.Settings.ACTION_MANAGE_WRITE_SETTINGS); + intent.setData(Uri.parse("package:" + getPackageName())); + startActivityForResult(intent, requestCodeForPermissionsWriteSettings); + return; + } + else if (s.equalsIgnoreCase(accessNotificationPolicyPermissionName)) + { + requiredPermissions.remove(s); + cachedPermissionsToRequest = requiredPermissions; + Intent intent = new Intent(android.provider.Settings.ACTION_NOTIFICATION_POLICY_ACCESS_SETTINGS); +// intent.setData(Uri.parse("package:" + getPackageName())); + startActivityForResult(intent, requestCodeForPermissionsNotificationPolicy); + return; + } + } + } + + if(requiredPermissions.size() > 0) + { + if(requiredPermissions.contains(permissionNameCall)) + { + if(!ActivityPermissions.isPermissionDeclaratedInManifest(Miscellaneous.getAnyContext(), "android.permission.SEND_SMS") + && + Miscellaneous.isGooglePlayInstalled(Miscellaneous.getAnyContext()) + ) + { + requiredPermissions.remove(permissionNameCall); + Miscellaneous.messageBox("Problem", getResources().getString(R.string.googleSarcasm), ActivityPermissions.this).show(); + } + } + if(requiredPermissions.contains("android.permission.SEND_SMS")) + { + if(!ActivityPermissions.isPermissionDeclaratedInManifest(Miscellaneous.getAnyContext(), "android.permission.SEND_SMS") + && + Miscellaneous.isGooglePlayInstalled(Miscellaneous.getAnyContext()) + ) + { + requiredPermissions.remove("android.permission.SEND_SMS"); + Miscellaneous.messageBox("Problem", getResources().getString(R.string.googleSarcasm), ActivityPermissions.this).show(); + } + } + + + StringBuilder permissions = new StringBuilder(); + for (String perm : requiredPermissions) + permissions.append(perm + "; "); + if (permissions.length() > 0) + permissions.delete(permissions.length() - 2, permissions.length()); + + Miscellaneous.logEvent("i", "Permissions", "Requesting permissions: " + permissions, 2); + +// Toast.makeText(ActivityPermissions.this, "Requesting permissions. Amount: " + String.valueOf(requiredPermissions.size()), Toast.LENGTH_LONG).show(); + requestPermissions(requiredPermissions.toArray(new String[requiredPermissions.size()]), requestCodeForPermissions); + } + else + setHaveAllPermissions(); + } + } + + protected void applyChanges() + { + AutomationService service = AutomationService.getInstance(); + if(service != null) + service.applySettingsAndRules(); + } + + @Override + public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) + { + Miscellaneous.logEvent("i", "onRequestPermissionsResult()", "onRequestPermissionsResult()", 3); +// Toast.makeText(ActivityPermissions.this, "onRequestPermissionsResult()", Toast.LENGTH_LONG).show(); + +// ArrayList disabledFeatures = new ArrayList(); + ArrayList deniedPermissions = new ArrayList(); + + if (requestCode == requestCodeForPermissions) + { + /*ArrayList affectedGeneralList = new ArrayList(); + ArrayList affectedTriggersList = new ArrayList(); + ArrayList affectedActionList = new ArrayList();*/ + + for (int i=0; i < grantResults.length; i++) + { + if(permissions[i].equalsIgnoreCase(writeExternalStoragePermissionName) && grantResults[i] == PackageManager.PERMISSION_GRANTED) + { + // We just got permission to read the config file. Read again. + try + { + XmlFileInterface.readFile(); + ActivityMainScreen.updateMainScreen(); + ActivityMainPoi.getInstance().updateListView(); + ActivityMainRules.getInstance().updateListView(); + ActivityMainProfiles.getInstance().updateListView(); + } + catch(Exception e) + { + Log.e("Error", Log.getStackTraceString(e)); + } + } + + if (grantResults[i] == PackageManager.PERMISSION_DENIED) + { +// User didn't allow at least 1 permission. What do we do now? +// Display the corresponding rules and otherwise deactivate them. + + /* for (String s : getGeneralAffectedFromDenial(permissions[i])) + addToArrayListUnique(s, affectedGeneralList); + + for (String s : getTriggerAffectedFromDenial(permissions[i])) + addToArrayListUnique(s, affectedTriggersList); + + for (String s : getActionAffectedFromDenial(permissions[i])) + addToArrayListUnique(s, affectedActionList);*/ + + deniedPermissions.add(permissions[i]); + } + } + + /* + * In theory we now have 3 arrays that hold the features which can't function. + */ + /*StringBuilder message = new StringBuilder(); + + for (String s : affectedGeneralList) + message.append(Miscellaneous.lineSeparator + s); + + for (String s : affectedTriggersList) + message.append(Miscellaneous.lineSeparator + s); + + for (String s : affectedActionList) + message.append(Miscellaneous.lineSeparator + s);*/ + + if(deniedPermissions.size() < permissions.length) + { + // At least one permission was granted. Apply settings. + applyChanges(); + } + if(deniedPermissions.size() > 0) + { + /* + The user denied certain permissions. With the exception of write-storage we need to live with that + and simply disable features while keeping the notification alive. The user may dismiss it anyway. + */ + + Miscellaneous.logEvent("w", "Denied permissions", getResources().getString(R.string.theFollowingPermissionsHaveBeenDenied) + Miscellaneous.explode(deniedPermissions), 3); +// this.finish(); + } + else + { + // All permissions have been granted. + setHaveAllPermissions(); + } + } + else + { +// I don't remember asking for permissions.... + } + } + + private void setHaveAllPermissions() + { + setResult(RESULT_OK); + // All permissions have been granted. + NotificationManager mNotificationManager = (NotificationManager) Miscellaneous.getAnyContext().getSystemService(Context.NOTIFICATION_SERVICE); + mNotificationManager.cancel(notificationIdPermissions); + ActivityMainScreen.updateMainScreen(); + this.finish(); + } + + private String[] getGeneralAffectedFromDenial(String permissionName) + { + ArrayList returnList = new ArrayList(); + + Iterator it = mapGeneralPermissions.entrySet().iterator(); + while (it.hasNext()) + { + Map.Entry pair = (Map.Entry) it.next(); + if (pair.getValue().equals(permissionName)) + addToArrayListUnique(pair.getKey(), returnList); + + it.remove(); // avoids a ConcurrentModificationException + } + + return returnList.toArray(new String[returnList.size()]); + } + + private String[] getTriggerAffectedFromDenial(String permissionName) + { + ArrayList returnList = new ArrayList(); + + Iterator it = mapTriggerPermissions.entrySet().iterator(); + while (it.hasNext()) + { + Map.Entry pair = (Map.Entry) it.next(); + if (pair.getValue().equals(permissionName)) + addToArrayListUnique(pair.getKey(), returnList); + + it.remove(); // avoids a ConcurrentModificationException + } + + return returnList.toArray(new String[returnList.size()]); + } + + private String[] getActionAffectedFromDenial(String permissionName) + { + ArrayList returnList = new ArrayList(); + + Iterator it = mapActionPermissions.entrySet().iterator(); + while (it.hasNext()) + { + Map.Entry pair = (Map.Entry) it.next(); + if (pair.getValue().equals(permissionName)) + addToArrayListUnique(pair.getKey(), returnList); + + it.remove(); // avoids a ConcurrentModificationException + } + + return returnList.toArray(new String[returnList.size()]); + } + + + protected static void fillPermissionMaps() + { + mapGeneralPermissions = new HashMap(); + mapGeneralPermissions.put("general", "android.permission.RECEIVE_BOOT_COMPLETED"); + mapGeneralPermissions.put("general", "android.permission.WRITE_EXTERNAL_STORAGE"); + + mapTriggerPermissions = new HashMap(); + mapTriggerPermissions.put("activityDetection", "com.google.android.gms.permission.ACTIVITY_RECOGNITION"); + mapTriggerPermissions.put("activityDetection", "android.permission.ACTIVITY_RECOGNITION"); + mapTriggerPermissions.put("airplaneMode", "android.permission.ACCESS_NETWORK_STATE"); + mapTriggerPermissions.put("batteryLevel", "android.permission.READ_PHONE_STATE"); + mapTriggerPermissions.put("batteryLevel", "android.permission.BATTERY_STATS"); + mapTriggerPermissions.put("bluetoothConnection", "android.permission.BLUETOOTH_ADMIN"); + mapTriggerPermissions.put("bluetoothConnection", "android.permission.BLUETOOTH"); + mapTriggerPermissions.put("bluetoothConnection", "android.permission.ACCESS_NETWORK_STATE"); + mapTriggerPermissions.put("charging", "android.permission.READ_PHONE_STATE"); + mapTriggerPermissions.put("charging", "android.permission.BATTERY_STATS"); + mapTriggerPermissions.put("headsetPlugged", "android.permission.READ_PHONE_STATE"); + mapTriggerPermissions.put("nfcTag", "android.permission.NFC"); + mapTriggerPermissions.put("noiseLevel", "android.permission.RECORD_AUDIO"); + mapTriggerPermissions.put("phoneCall", "android.permission.READ_PHONE_STATE"); + mapTriggerPermissions.put("phoneCall", permissionNameCall); + mapTriggerPermissions.put("pointOfInterest", permissionNameLocationFine); + mapTriggerPermissions.put("pointOfInterest", permissionNameLocationCoarse); + if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) + mapTriggerPermissions.put("pointOfInterest", permissionNameLocationBackground); + mapTriggerPermissions.put("pointOfInterest", "android.permission.ACCESS_NETWORK_STATE"); + mapTriggerPermissions.put("pointOfInterest", "android.permission.INTERNET"); + mapTriggerPermissions.put("pointOfInterest", "android.permission.ACCESS_WIFI_STATE"); + mapTriggerPermissions.put("process_started_stopped", "android.permission.GET_TASKS"); + mapTriggerPermissions.put("roaming", "android.permission.ACCESS_NETWORK_STATE"); + mapTriggerPermissions.put("speed", permissionNameLocationFine); + mapTriggerPermissions.put("speed", permissionNameLocationCoarse); + if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) + mapTriggerPermissions.put("speed", permissionNameLocationBackground); + mapTriggerPermissions.put("speed", "android.permission.ACCESS_NETWORK_STATE"); + mapTriggerPermissions.put("speed", "android.permission.INTERNET"); +// map.put("timeFrame", ""); + mapTriggerPermissions.put("usb_host_connection", "android.permission.READ_PHONE_STATE"); + mapTriggerPermissions.put("usb_host_connection", "android.permission.BATTERY_STATS"); + mapTriggerPermissions.put("wifiConnection", "android.permission.ACCESS_NETWORK_STATE"); + mapTriggerPermissions.put("wifiConnection", "android.permission.ACCESS_WIFI_STATE"); + + mapActionPermissions = new HashMap(); + mapActionPermissions.put("changeSoundProfile", "android.permission.MODIFY_AUDIO_SETTINGS"); + mapActionPermissions.put("changeSoundProfile", accessNotificationPolicyPermissionName); + mapActionPermissions.put("disableScreenRotation", writeSystemSettingsPermissionName); + mapActionPermissions.put("enableScreenRotation", writeSystemSettingsPermissionName); +// mapActionPermissions.put("playMusic", ""); + mapActionPermissions.put("sendTextMessage", "android.permission.SEND_SMS"); + mapActionPermissions.put("setAirplaneMode", writeSystemSettingsPermissionName); + mapActionPermissions.put("setAirplaneMode", "android.permission.ACCESS_NETWORK_STATE"); + mapActionPermissions.put("setAirplaneMode", "android.permission.ACCESS_SUPERUSER"); + mapActionPermissions.put("setAirplaneMode", "android.permission.CHANGE_NETWORK_STATE"); + mapActionPermissions.put("setBluetooth", "android.permission.BLUETOOTH_ADMIN"); + mapActionPermissions.put("setBluetooth", "android.permission.BLUETOOTH"); + mapActionPermissions.put("setBluetooth", "android.permission.ACCESS_NETWORK_STATE"); + mapActionPermissions.put("setBluetooth", writeSystemSettingsPermissionName); + mapActionPermissions.put("setDataConnection", writeSystemSettingsPermissionName); + mapActionPermissions.put("setDataConnection", "android.permission.ACCESS_NETWORK_STATE"); + mapActionPermissions.put("setDataConnection", "android.permission.ACCESS_SUPERUSER"); + mapActionPermissions.put("setDataConnection", "android.permission.CHANGE_NETWORK_STATE"); + mapActionPermissions.put("setDisplayRotation", writeSystemSettingsPermissionName); + mapActionPermissions.put("setUsbTethering", writeSystemSettingsPermissionName); + mapActionPermissions.put("setUsbTethering", "android.permission.CHANGE_NETWORK_STATE"); + mapActionPermissions.put("setWifi", writeSystemSettingsPermissionName); + mapActionPermissions.put("setWifi", "android.permission.CHANGE_NETWORK_STATE"); + mapActionPermissions.put("setWifi", "android.permission.ACCESS_NETWORK_STATE"); + mapActionPermissions.put("setWifiTethering", writeSystemSettingsPermissionName); + mapActionPermissions.put("setWifiTethering", "android.permission.CHANGE_NETWORK_STATE"); + mapActionPermissions.put("setWifiTethering", "android.permission.ACCESS_NETWORK_STATE"); +// mapActionPermissions.put("speakText", accessNotificationPolicyPermissionName); +// mapActionPermissions.put("startOtherActivity", ""); + mapActionPermissions.put("triggerUrl", "android.permission.INTERNET"); +// Hier müßte ein Hinweis kommen, daß nur die Variablen verwendet werden können, für die es Rechte gibt. + mapActionPermissions.put("turnBluetoothOff", "android.permission.BLUETOOTH_ADMIN"); + mapActionPermissions.put("turnBluetoothOff", "android.permission.BLUETOOTH"); + mapActionPermissions.put("turnBluetoothOff", "android.permission.ACCESS_NETWORK_STATE"); + mapActionPermissions.put("turnBluetoothOff", writeSystemSettingsPermissionName); + mapActionPermissions.put("turnBluetoothOn", "android.permission.BLUETOOTH_ADMIN"); + mapActionPermissions.put("turnBluetoothOn", "android.permission.BLUETOOTH"); + mapActionPermissions.put("turnBluetoothOn", "android.permission.ACCESS_NETWORK_STATE"); + mapActionPermissions.put("turnBluetoothOn", writeSystemSettingsPermissionName); + mapActionPermissions.put("turnUsbTetheringOff", writeSystemSettingsPermissionName); + mapActionPermissions.put("turnUsbTetheringOff", "android.permission.CHANGE_NETWORK_STATE"); + mapActionPermissions.put("turnUsbTetheringOn", writeSystemSettingsPermissionName); + mapActionPermissions.put("turnUsbTetheringOn", "android.permission.CHANGE_NETWORK_STATE"); + mapActionPermissions.put("turnWifiOff", writeSystemSettingsPermissionName); + mapActionPermissions.put("turnWifiOff", "android.permission.CHANGE_NETWORK_STATE"); + mapActionPermissions.put("turnWifiOff", "android.permission.ACCESS_NETWORK_STATE"); + mapActionPermissions.put("turnWifiOn", writeSystemSettingsPermissionName); + mapActionPermissions.put("turnWifiOn", "android.permission.CHANGE_NETWORK_STATE"); + mapActionPermissions.put("turnWifiOn", "android.permission.ACCESS_NETWORK_STATE"); + mapActionPermissions.put("turnWifiTetheringOff", writeSystemSettingsPermissionName); + mapActionPermissions.put("turnWifiTetheringOff", "android.permission.CHANGE_NETWORK_STATE"); + mapActionPermissions.put("turnWifiTetheringOff", "android.permission.ACCESS_NETWORK_STATE"); + mapActionPermissions.put("turnWifiTetheringOn", writeSystemSettingsPermissionName); + mapActionPermissions.put("turnWifiTetheringOn", "android.permission.CHANGE_NETWORK_STATE"); + mapActionPermissions.put("turnWifiTetheringOn", "android.permission.ACCESS_NETWORK_STATE"); +// mapActionPermissions.put("waitBeforeNextAction", ""); + mapActionPermissions.put("wakeupDevice", "android.permission.WAKE_LOCK"); + } + + /* + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + */ + + public static boolean isPermissionDeclaratedInManifest(Context context, String permission) + { + PackageManager pm = context.getPackageManager(); + try + { + PackageInfo packageInfo = pm.getPackageInfo(context.getPackageName(), PackageManager.GET_PERMISSIONS); + String[] requestedPermissions = null; + if (packageInfo != null) + { + requestedPermissions = packageInfo.requestedPermissions; + } + + if (requestedPermissions != null && requestedPermissions.length > 0) + { + List requestedPermissionsList = Arrays.asList(requestedPermissions); + ArrayList requestedPermissionsArrayList = new ArrayList(); + requestedPermissionsArrayList.addAll(requestedPermissionsList); + return (requestedPermissionsArrayList.contains(permission)); +// Log.i(ExConsts.TAG, ""+requestedPermissionsArrayList); + } + } + catch (PackageManager.NameNotFoundException e) + { + e.printStackTrace(); + } + + return false; + } +} diff --git a/app/src/main/java/com/jens/automation2/ActivitySettings.java b/app/src/main/java/com/jens/automation2/ActivitySettings.java new file mode 100644 index 0000000..21fa8e8 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivitySettings.java @@ -0,0 +1,19 @@ +package com.jens.automation2; + +import android.os.Bundle; +import android.preference.ListPreference; +import android.preference.PreferenceActivity; + +import com.jens.automation2.R.layout; + +public class ActivitySettings extends PreferenceActivity +{ + ListPreference lpStartScreenOptionsValues; + + @Override + protected void onCreate(Bundle savedInstanceState) + { + super.onCreate(savedInstanceState); + addPreferencesFromResource(layout.settings); + } +} diff --git a/app/src/main/java/com/jens/automation2/ActivityVolumeTest.java b/app/src/main/java/com/jens/automation2/ActivityVolumeTest.java new file mode 100644 index 0000000..7c4de0b --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ActivityVolumeTest.java @@ -0,0 +1,210 @@ +package com.jens.automation2; + +import android.annotation.SuppressLint; +import android.app.Activity; +import android.media.MediaRecorder; +import android.os.AsyncTask; +import android.os.Bundle; +import android.widget.EditText; +import android.widget.SeekBar; +import android.widget.SeekBar.OnSeekBarChangeListener; +import android.widget.TextView; +import android.widget.Toast; + +@SuppressLint("NewApi") +public class ActivityVolumeTest extends Activity +{ + TextView tvCurrentVolume, tvVolumeTestExplanation; + EditText etReferenceValue; + SeekBar sbReferenceValue; + + final int volumeRefreshInterval = 3; + + static ActivityVolumeTest instance = null; + + AsyncTask volumeTask = null; + + @Override + protected void onCreate(Bundle savedInstanceState) + { + instance = this; + + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_volume_test); + + tvCurrentVolume = (TextView)findViewById(R.id.tvCurrentVolume); + etReferenceValue = (EditText)findViewById(R.id.etReferenceValue); + sbReferenceValue = (SeekBar)findViewById(R.id.sbReferenceValue); + tvVolumeTestExplanation = (TextView)findViewById(R.id.tvVolumeTestExplanation); + + tvVolumeTestExplanation.setText(String.format(getResources().getString(R.string.volumeTesterExplanation), String.valueOf(volumeRefreshInterval))); + + etReferenceValue.setText(String.valueOf(Settings.referenceValueForNoiseLevelMeasurements)); + + sbReferenceValue.setMax(500); + sbReferenceValue.setProgress((int) Settings.referenceValueForNoiseLevelMeasurements); + sbReferenceValue.setOnSeekBarChangeListener(new OnSeekBarChangeListener() + { + @Override + public void onStopTrackingTouch(SeekBar seekBar) + { + // TODO Auto-generated method stub + + } + + @Override + public void onStartTrackingTouch(SeekBar seekBar) + { + // TODO Auto-generated method stub + + } + + @Override + public void onProgressChanged(SeekBar seekBar, int progress, + boolean fromUser) + { + etReferenceValue.setText(String.valueOf(sbReferenceValue.getProgress())); + } + }); + } + + @Override + protected void onResume() + { + super.onResume(); + + startVolumeMonitoring(); + } + + @Override + protected void onPause() + { + super.onPause(); + stopVolumeMonitoring(); + } + + public static ActivityVolumeTest getInstance() + { + return instance; + } + + @Override + public void onBackPressed() + { + try + { + stopVolumeMonitoring(); + Settings.referenceValueForNoiseLevelMeasurements = Long.parseLong(etReferenceValue.getText().toString()); + Settings.writeSettings(ActivityVolumeTest.this); + super.onBackPressed(); + } + catch (Exception e) + { + Toast.makeText(ActivityVolumeTest.this, ActivityVolumeTest.this.getResources().getString(R.string.enterValidReferenceValue), Toast.LENGTH_LONG).show(); + } + } + + synchronized private void startVolumeMonitoring() + { + volumeTask = new NoiseListenerMeasuring(); + +// if(!(volumeTask.getStatus() == AsyncTask.Status.PENDING | volumeTask.getStatus() != AsyncTask.Status.RUNNING)) + volumeTask.execute(volumeRefreshInterval); + } + + synchronized private void stopVolumeMonitoring() + { +// if(volumeTask != null && (volumeTask.getStatus() == Status.PENDING | volumeTask.getStatus() == Status.RUNNING)) + volumeTask.cancel(true); + } + + synchronized void updateDisplayedNoiseLevel(long noise) + { + tvCurrentVolume.setText(String.valueOf(noise) + " dB"); + } + + private static class NoiseListenerMeasuring extends AsyncTask + { + static boolean isNoiseMonitoringActive; + + @Override + protected Void doInBackground(Integer... interval) + { + if(!isNoiseMonitoringActive) + { + isNoiseMonitoringActive = true; + + Miscellaneous.logEvent("i", "Noise level", "Periodic noise level measurement started.", 5); + + while(!isCancelled()) + { + try + { + // Start recording but don't store data + MediaRecorder mediaRecorder = new MediaRecorder(); + mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC); + mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP); + mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB); + mediaRecorder.setOutputFile("/dev/null"); + // Date myDate = new Date(); + // mediaRecorder.setOutputFile("/sdcard/temp/" + String.valueOf(myDate.getTime()) + ".3gpp"); + + mediaRecorder.prepare(); + mediaRecorder.getMaxAmplitude(); + mediaRecorder.start(); + mediaRecorder.getMaxAmplitude(); + + long noiseLevel; + + try + { + Thread.sleep(interval[0] * 1000); + // Obtain maximum amplitude since last call of getMaxAmplitude() + noiseLevel = mediaRecorder.getMaxAmplitude(); + } + catch(Exception e) + { + noiseLevel = -1; + Miscellaneous.logEvent("e", "Noise level", "Error getting noise level: " + e.getMessage(), 2); + } + + double currentReferenceValue = Double.parseDouble(ActivityVolumeTest.getInstance().etReferenceValue.getText().toString()); + double db = 20 * Math.log(noiseLevel / currentReferenceValue); + long noiseLevelDb = Math.round(db); + + publishProgress(noiseLevelDb); + + // Message answer = new Message(); + // Bundle answerBundle = new Bundle(); + // answerBundle.putLong("noiseLevelDb", noiseLevelDb); + // answer.setData(answerBundle); + // volumeHandler.sendMessage(answer); + + // Don't forget to release + mediaRecorder.reset(); + mediaRecorder.release(); + + Miscellaneous.logEvent("i", "Noise level", "Measured noise level: " + String.valueOf(noiseLevel) + " / converted to db: " + String.valueOf(db), 3); + } + catch(Exception e) + {} + } + + isNoiseMonitoringActive = false; + + Miscellaneous.logEvent("i", "Noise level", "Periodic noise level measurement stopped.", 5); + } + return null; + } + + @Override + protected void onProgressUpdate(Long... values) + { + ActivityVolumeTest.getInstance().updateDisplayedNoiseLevel(values[0]); + +// super.onProgressUpdate(values); + } + + + } +} diff --git a/app/src/main/java/com/jens/automation2/AutomationService.java b/app/src/main/java/com/jens/automation2/AutomationService.java new file mode 100644 index 0000000..aabe905 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/AutomationService.java @@ -0,0 +1,713 @@ +package com.jens.automation2; + +import android.annotation.SuppressLint; +import android.app.ActivityManager; +import android.app.ActivityManager.RunningServiceInfo; +import android.app.Notification; +import android.app.Notification.Builder; +import android.app.NotificationChannel; +import android.app.NotificationManager; +import android.app.PendingIntent; +import android.app.Service; +import android.content.Context; +import android.content.Intent; +import android.media.AudioManager; +import android.os.Binder; +import android.os.Build; +import android.os.Bundle; +import android.os.Environment; +import android.os.IBinder; +import android.speech.tts.TextToSpeech; +import android.speech.tts.TextToSpeech.OnInitListener; +import android.util.Log; +import android.widget.Toast; + +import androidx.core.app.NotificationCompat; + +import com.jens.automation2.Trigger.Trigger_Enum; +import com.jens.automation2.location.LocationProvider; +import com.jens.automation2.receivers.PackageReplacedReceiver; +import com.jens.automation2.receivers.PhoneStatusListener; + +import java.util.Calendar; + +@SuppressLint("NewApi") +public class AutomationService extends Service implements OnInitListener +{ + protected TextToSpeech ttsEngine = null; + protected final static int notificationId = 1000; + + final static String NOTIFICATION_CHANNEL_ID = "com.jens.automation2"; + final static String channelName = "Automation notifications"; + + protected static Notification myNotification; + protected static NotificationCompat.Builder notificationBuilder = null; + protected static PendingIntent myPendingIntent; + + protected Calendar lockSoundChangesEnd = null; + protected boolean isRunning; + + public void nullLockSoundChangesEnd() + { + lockSoundChangesEnd = null; + } + public Calendar getLockSoundChangesEnd() + { + return lockSoundChangesEnd; + } + public void lockSoundChangesEndAddTime() + { + if(lockSoundChangesEnd == null) + lockSoundChangesEnd = Calendar.getInstance(); + + lockSoundChangesEnd.add(Calendar.MINUTE, Settings.lockSoundChangesInterval); +// ActivityMainScreen.getActivityMainScreenInstance().updateMainScreen(); + } + + public void checkLockSoundChangesTimeElapsed() + { + Calendar now = Calendar.getInstance(); + if(getLockSoundChangesEnd() != null && getLockSoundChangesEnd().getTimeInMillis() <= now.getTimeInMillis()) + lockSoundChangesEnd = null; + } + + public void setLockSoundChangesEnd(Calendar lockSoundChangesEnd) + { + this.lockSoundChangesEnd = lockSoundChangesEnd; + } + + protected final IBinder myBinder = new LocalBinder(); + + protected LocationProvider myLocationProvider; + + public LocationProvider getLocationProvider() + { + return myLocationProvider; + } + + protected static AutomationService centralInstance = null; + + public static AutomationService getInstance() + { + return centralInstance; + } + + @Override + public void onCreate() + { + super.onCreate(); + + Thread.setDefaultUncaughtExceptionHandler(Miscellaneous.uncaughtExceptionHandler); + + // Store a reference to myself. Other classes often need a context or something, this can provide that. + centralInstance = this; + } + + public boolean checkStartupRequirements(Context context, boolean startAtBoot) + { + if (!ActivityPermissions.havePermission(ActivityPermissions.writeExternalStoragePermissionName, AutomationService.this)) + { + /* + Don't have permission to access external storage. This is a show stopper as + the configuration file is stored on external storage. + */ + Miscellaneous.logEvent("e", "Permission", "Don't have permission to access external storage. Will request it now.", 4); +// Toast.makeText(AutomationService.this, getResources().getString(R.string.appRequiresPermissiontoAccessExternalStorage), Toast.LENGTH_LONG).show(); + ActivityPermissions.requestSpecificPermission(ActivityPermissions.writeExternalStoragePermissionName); + return false; + } + + if(Build.VERSION.SDK_INT >= 28) + { + if (!ActivityPermissions.havePermission(ActivityPermissions.permissionNameStartService, AutomationService.this)) + { + /* + Don't have permission to start service. This is a show stopper. + */ + Miscellaneous.logEvent("e", "Permission", "Don't have permission to start foreground service. Will request it now.", 4); +// Toast.makeText(AutomationService.this, getResources().getString(R.string.appRequiresPermissiontoAccessExternalStorage), Toast.LENGTH_LONG).show(); + ActivityPermissions.requestSpecificPermission(ActivityPermissions.permissionNameStartService); + return false; + } + } + + if (PointOfInterest.getPointOfInterestCollection() == null | PointOfInterest.getPointOfInterestCollection().size() == 0 + | + Rule.getRuleCollection() == null | Rule.getRuleCollection().size() == 0 + ) + { + if (startAtBoot) + { + /* + * In case we start at boot the sd card may not have been mounted, yet. + * We will wait 3 seconds and check and do this 3 times. + */ + if (!XmlFileInterface.settingsFile.exists()) + { + for (int i = 0; i < 3; i++) + { + String state = Environment.getExternalStorageState(); + if (!state.equals(Environment.MEDIA_MOUNTED)) + { + try + { + Miscellaneous.logEvent("w", "AutoStart", "Service is started via boot. Settingsfile not available because storage is not mounted, yet. Waiting for 3 seconds.", 4); + Thread.sleep(3000); + } catch (InterruptedException e) + { + e.printStackTrace(); + } + } + if (XmlFileInterface.settingsFile.exists()) + break; + } + } + } + PointOfInterest.loadPoisFromFile(); + Rule.readFromFile(); + } + + //if still no POIs... + if (//PointOfInterest.getPointOfInterestCollection() == null | PointOfInterest.getPointOfInterestCollection().size() == 0 + // && + Rule.getRuleCollection() == null | Rule.getRuleCollection().size() == 0 + ) + { + Miscellaneous.logEvent("w", "AutomationService", context.getResources().getString(R.string.serviceWontStart), 1); + Toast.makeText(context, context.getResources().getString(R.string.serviceWontStart), Toast.LENGTH_LONG).show(); + return false; + } else + { + return true; + } + } + + @Override + public int onStartCommand(Intent intent, int flags, int startId) + { + boolean startAtBoot = false; + + if (intent != null) + { + Bundle b = intent.getExtras(); + startAtBoot = b.getBoolean("startAtBoot", false); + } + + if (checkStartupRequirements(this, startAtBoot)) + { + Miscellaneous.logEvent("i", "Service", this.getResources().getString(R.string.logServiceStarting), 1); + + startUpRoutine(); + + Intent myIntent = new Intent(this, ActivityMainTabLayout.class); + myPendingIntent = PendingIntent.getActivity(this, 0, myIntent, 0); + notificationBuilder = createDefaultNotificationBuilder(); + + updateNotification(); + + if (isMainActivityRunning(this)) + ActivityMainScreen.updateMainScreen(); + + this.isRunning = true; + Miscellaneous.logEvent("i", "Service", this.getResources().getString(R.string.serviceStarted) + " " + String.format(this.getResources().getString(R.string.version), BuildConfig.VERSION_NAME + "(Build " + BuildConfig.VERSION_CODE + ")"), 1); + Toast.makeText(this, this.getResources().getString(R.string.serviceStarted), Toast.LENGTH_LONG).show(); + // ********** Test area ********** +// Miscellaneous.logEvent("i", "setNetworkType", "bin hier.", 3); +// Actions.setData(true); + // ********** Test area ********** + + return START_STICKY; + } + else + { + Miscellaneous.logEvent("e", "Service", "checkStartupRequirements() delivered false. Stopping service...", 1); + this.stopSelf(); + return START_NOT_STICKY; + } + } + + @Override + public IBinder onBind(Intent arg0) + { + return myBinder; + } + + public enum serviceCommands + { + reloadSettings, reloadPointsOfInterest, reloadRules, updateNotification + } + + ; + + public void serviceInterface(serviceCommands command) + { + Miscellaneous.logEvent("i", "Bind", "Ahhhh, customers... How can I help you?", 5); + + Miscellaneous.logEvent("i", "ServiceBind", "Request to " + command.toString(), 5); + + switch (command) + { + case reloadPointsOfInterest: + PointOfInterest.loadPoisFromFile(); + break; + case reloadRules: + Rule.readFromFile(); + break; + case reloadSettings: + Settings.readFromPersistentStorage(this); + applySettingsAndRules(); + myLocationProvider.applySettingsAndRules(); + break; + case updateNotification: + this.updateNotification(); + ActivityMainScreen.updateMainScreen(); + break; + default: + break; + } + } + + public void applySettingsAndRules() + { + if (Settings.useTextToSpeechOnNormal | Settings.useTextToSpeechOnSilent | Settings.useTextToSpeechOnVibrate) + { + if (ttsEngine == null) + ttsEngine = new TextToSpeech(this, this); + } + else + { + if (ttsEngine != null) + ttsEngine.shutdown(); + } + + startLocationProvider(); + ReceiverCoordinator.startAllReceivers(); + if(myLocationProvider != null) // This condition can be met if the user has no locations defined. + myLocationProvider.applySettingsAndRules(); + + ReceiverCoordinator.applySettingsAndRules(); + } + + @Override + public void onDestroy() + { + Miscellaneous.logEvent("i", "Service", getResources().getString(R.string.logServiceStopping), 1); + + stopRoutine(); + this.isRunning = false; + Toast.makeText(this, getResources().getString(R.string.serviceStopped), Toast.LENGTH_LONG).show(); + Miscellaneous.logEvent("i", "Service", getResources().getString(R.string.serviceStopped), 1); + } + + public void checkForTtsEngine() + { + if (Settings.useTextToSpeechOnNormal | Settings.useTextToSpeechOnSilent | Settings.useTextToSpeechOnVibrate | Rule.isAnyRuleUsing(Action.Action_Enum.speakText)) + { + if (ttsEngine == null) + ttsEngine = new TextToSpeech(this, this); + } else + { + if (ttsEngine != null) + ttsEngine.shutdown(); + } + } + + private void startUpRoutine() + { + checkForTtsEngine(); + checkForPermissions(); + + Actions.context = this; + Actions.autoMationServerRef = this; + + startLocationProvider(); + ReceiverCoordinator.startAllReceivers(); + + PackageReplacedReceiver.setHasServiceBeenRunning(true, this); + } + + protected void startLocationProvider() + { + if(ActivityPermissions.havePermission("android.permission.ACCESS_COARSE_LOCATION", AutomationService.this)) + myLocationProvider = new LocationProvider(this); //autostart with this (only) constructor + } + + protected void checkForPermissions() + { + if(ActivityPermissions.needMorePermissions(AutomationService.this)) + { + boolean displayNotification = false; + + for(Rule r : Rule.getRuleCollection()) + { + if(r.isRuleActive()) + { + if(!r.haveEnoughPermissions()) +// for (String permission : ActivityPermissions.getPermissionsForRule(r)) + { +// if (!ActivityPermissions.havePermission(permission, AutomationService.this)) + { +// r.setRuleActive(false); +// r.change(AutomationService.this); + if(!displayNotification) + displayNotification = true; + } + } + } + } + + if(displayNotification) + { +// Toast.makeText(Miscellaneous.getAnyContext(), "Require more permissions.", Toast.LENGTH_LONG).show(); + // Update notification or show new one that notifiies of the lack or permissions. + + Intent intent = new Intent(AutomationService.this, ActivityPermissions.class); + PendingIntent pi = PendingIntent.getActivity(AutomationService.this, 0, intent, 0); + Miscellaneous.createDismissableNotification(getResources().getString(R.string.appRunningInLimitedMode), ActivityPermissions.notificationIdPermissions, pi); + } +// else +// Toast.makeText(Miscellaneous.getAnyContext(), "Have all required permissions.", Toast.LENGTH_LONG).show(); + } + } + + public static void startAutomationService(Context context, boolean startAtBoot) + { + if(!(isMyServiceRunning(context))) + { + Intent myServiceIntent = new Intent(context, AutomationService.class); + myServiceIntent.putExtra("startAtBoot", startAtBoot); + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) + context.startForegroundService(myServiceIntent); + else + context.startService(myServiceIntent); + } + else + Miscellaneous.logEvent("i", "Service", "Service is already running.", 1); + } + + private void stopRoutine() + { + Log.i("STOP", "Stopping"); + try + { + myLocationProvider.stopLocationService(); + ReceiverCoordinator.stopAllReceivers(); + } + catch(NullPointerException e) + { + Miscellaneous.logEvent("e", getResources().getString(R.string.serviceNotRunning), getResources().getString(R.string.serviceNotRunning) + ". " + getResources().getString(R.string.cantStopIt), 3); + } + + if(ttsEngine != null) + ttsEngine.shutdown(); + + PackageReplacedReceiver.setHasServiceBeenRunning(false, this); + } + + protected static Builder createDefaultNotificationBuilderOld() + { + Builder builder = new Builder(AutomationService.getInstance()); + builder.setContentTitle("Automation"); + + if(Settings.showIconWhenServiceIsRunning) + builder.setSmallIcon(R.drawable.ic_launcher); + + builder.setCategory(Notification.CATEGORY_SERVICE); + builder.setWhen(System.currentTimeMillis()); + builder.setContentIntent(myPendingIntent); + +// Notification defaultNotification = new Notification(); + Notification defaultNotification = builder.build(); + + defaultNotification.icon = R.drawable.ic_launcher; + defaultNotification.when = System.currentTimeMillis(); + +// defaultNotification.defaults |= Notification.DEFAULT_VIBRATE; +// defaultNotification.defaults |= Notification.DEFAULT_LIGHTS; + + defaultNotification.flags |= Notification.FLAG_AUTO_CANCEL; +// defaultNotification.flags |= Notification.FLAG_SHOW_LIGHTS; + defaultNotification.flags |= Notification.FLAG_ONLY_ALERT_ONCE; + +// defaultNotification.ledARGB = Color.YELLOW; +// defaultNotification.ledOnMS = 1500; +// defaultNotification.ledOffMS = 1500; + + return builder; + + /*NotificationManager mNotificationManager = (NotificationManager) AutomationService.getInstance().getSystemService(Context.NOTIFICATION_SERVICE); + + NotificationCompat.Builder builder; + builder = new NotificationCompat.Builder(AutomationService.getInstance()); + + if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) + builder.setCategory(Notification.CATEGORY_EVENT); + + builder.setWhen(System.currentTimeMillis()); + + builder.setContentTitle("Automation"); + builder.setSmallIcon(R.drawable.ic_launcher); +// builder.setContentText(textToDisplay); +// builder.setSmallIcon(icon); +// builder.setContentIntent(pendingIntent); +// builder.setStyle(new NotificationCompat.BigTextStyle().bigText(textToDisplay)); + + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) + { + NotificationChannel channel = new NotificationChannel("notify_001", "Channel human readable title", NotificationManager.IMPORTANCE_DEFAULT); + mNotificationManager.createNotificationChannel(channel); + } + + return builder;*/ + } + + protected static NotificationCompat.Builder createDefaultNotificationBuilder() + { + NotificationManager mNotificationManager = (NotificationManager) AutomationService.getInstance().getSystemService(Context.NOTIFICATION_SERVICE); + + NotificationCompat.Builder builder; + + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) + { + NotificationChannel chan = new NotificationChannel(NOTIFICATION_CHANNEL_ID, channelName, NotificationManager.IMPORTANCE_LOW); +// chan.setLightColor(Color.BLUE); + chan.enableVibration(false); + chan.setSound(null, null); + chan.setLockscreenVisibility(Notification.VISIBILITY_PRIVATE); + mNotificationManager.createNotificationChannel(chan); + + builder = new NotificationCompat.Builder(AutomationService.getInstance(), NOTIFICATION_CHANNEL_ID); + } + else + builder = new NotificationCompat.Builder(AutomationService.getInstance()); + + if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) + builder.setCategory(Notification.CATEGORY_SERVICE); + + builder.setWhen(System.currentTimeMillis()); + builder.setContentIntent(myPendingIntent); + + builder.setContentTitle(AutomationService.getInstance().getResources().getString(R.string.app_name)); + builder.setOnlyAlertOnce(true); + + if(Settings.showIconWhenServiceIsRunning) + builder.setSmallIcon(R.drawable.ic_launcher); + +// builder.setContentText(textToDisplay); +// builder.setSmallIcon(icon); +// builder.setStyle(new NotificationCompat.BigTextStyle().bigText(textToDisplay)); + + return builder; + } + + @SuppressLint("NewApi") + @SuppressWarnings("deprecation") + public static void updateNotification() + { + AutomationService instance = getInstance(); + + if(instance != null) + { +// if(Settings.showIconWhenServiceIsRunning) +// { + Miscellaneous.logEvent("i", "Notification", "Request to update notification.", 4); + + String bodyText=""; + String lastRuleString = ""; + + if(PointOfInterest.getPointOfInterestCollection() != null && PointOfInterest.getPointOfInterestCollection().size() > 0) + { + try + { + PointOfInterest activePoi = PointOfInterest.getActivePoi(); + if(activePoi == null) + { + PointOfInterest closestPoi = PointOfInterest.getClosestPOI(instance.getLocationProvider().getCurrentLocation()); + bodyText = "Active POI: none" + "\n" + "Closest POI: " + closestPoi.getName() + lastRuleString; + } + else + { + bodyText = "Active POI: " + activePoi.getName() + lastRuleString; + } + } + catch(NullPointerException e) + { + if( + Rule.isAnyRuleUsing(Trigger_Enum.pointOfInterest) + && + ActivityPermissions.havePermission(ActivityPermissions.permissionNameLocationCoarse, AutomationService.getInstance()) + && + ActivityPermissions.havePermission(ActivityPermissions.permissionNameLocationFine, AutomationService.getInstance()) + ) + bodyText = instance.getResources().getString(R.string.stillGettingPosition); + else + bodyText = instance.getResources().getString(R.string.locationEngineNotActive); + } + } + + try + { + lastRuleString = instance.getResources().getString(R.string.lastRule) + " " + Rule.getLastActivatedRule().getName() + " " + instance.getResources().getString(R.string.at) + " " + Rule.getLastActivatedRuleActivationTime().toLocaleString(); + } + catch(Exception e) + { + lastRuleString = instance.getResources().getString(R.string.lastRule) + " n./a."; + } + + String textToDisplay = bodyText + " " + lastRuleString; +// if(Build.VERSION.SDK_INT < 11) +// { +// myNotification.setLatestEventInfo(instance, "Automation", textToDisplay, myPendingIntent); +// } +// else +// { + notificationBuilder.setContentText(textToDisplay); + notificationBuilder.setStyle(new NotificationCompat.BigTextStyle().bigText(textToDisplay)); + + myNotification = notificationBuilder.build(); + myNotification.defaults = 0; +// } + +// NotificationManager notificationManager = (NotificationManager) instance.getSystemService(NOTIFICATION_SERVICE); + // hide the notification after its selected +// myNotification.flags |= Notification.FLAG_AUTO_CANCEL; + myNotification.flags |= Notification.FLAG_NO_CLEAR; +// notificationManager.notify(notificationId, myNotification); + + instance.startForeground(notificationId, myNotification); +// } +// else +// instance.startForeground(notificationId, null); // do not show icon in task bar + } + } + + public class LocalBinder extends Binder + { + public AutomationService getService() + { + return AutomationService.this; + } + } + + @Override + public void onInit(int status) + { + // TODO Auto-generated method stub + + } + + /** + * force will skip volume settings and stuff + **/ + public void speak(String text, boolean force) + { + if(text.length() > 0 && (force | Settings.useTextToSpeechOnNormal | Settings.useTextToSpeechOnSilent | Settings.useTextToSpeechOnVibrate)) + { + AudioManager myAudioManager = (AudioManager)getSystemService(Context.AUDIO_SERVICE); + int mode = myAudioManager.getRingerMode(); + + if( + (mode == AudioManager.RINGER_MODE_NORMAL && Settings.useTextToSpeechOnNormal) + | + (mode == AudioManager.RINGER_MODE_VIBRATE && Settings.useTextToSpeechOnVibrate) + | + (mode == AudioManager.RINGER_MODE_SILENT && Settings.useTextToSpeechOnSilent) + | + force + ) + { + if(Settings.muteTextToSpeechDuringCalls && PhoneStatusListener.isInACall() && !force) + { + Miscellaneous.logEvent("i", "TextToSpeech", "Currently in a call. Not speaking as requested.", 4); + return; + } + else + { + try + { + for(int i = 0; i < 5; i++) + { + if(ttsEngine != null) + { + break; + } + else + { + try + { + Miscellaneous.logEvent("i", "TTS", "Waiting for a moment to give the TTS service time to load...", 4); + Thread.sleep(1000); // give the tts engine time to load + } + catch(Exception e) + {} + } + } + this.ttsEngine.speak(text, TextToSpeech.QUEUE_ADD, null); + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "TextToSpeech", Log.getStackTraceString(e), 3); + e.printStackTrace(); + } + } + } + } + } + + public static boolean isMainActivityRunning(Context context) + { + if(ActivityMainScreen.getActivityMainScreenInstance() == null) + return false; + else + return true; + +// boolean isActivityFound = false; +// ActivityManager activityManager = (ActivityManager)context.getSystemService (Context.ACTIVITY_SERVICE); +// List activitys = activityManager.getRunningTasks(Integer.MAX_VALUE); +// isActivityFound = false; +// for (int i = 0; i < activitys.size(); i++) +// { +// if (activitys.get(i).topActivity.toString().equalsIgnoreCase("ComponentInfo{com.jens.automation/com.jens.automation.ActivityMainScreen}")) +// { +// isActivityFound = true; +// } +// } +// Miscellaneous.logEvent("i", "ActivityMainScreen", "Activity running status: " + String.valueOf(isActivityFound), 5); +// return isActivityFound; + +// ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE); +// List tasks = activityManager.getRunningTasks(Integer.MAX_VALUE); +// +// for (RunningTaskInfo task : tasks) +// { +// if (context.getPackageName().equalsIgnoreCase(task.baseActivity.getPackageName())) +// return true; +// } +// +// return false; + } + + public static boolean isMyServiceRunning(Context context) + { + try + { + ActivityManager manager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE); + for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) + { + if(AutomationService.class.getName().equals(service.service.getClassName())) + { +// return AutomationService.getInstance() != null && AutomationService.getInstance().isRunning; + return true; + } + } + } + catch(NullPointerException e) + { + if(Log.getStackTraceString(e).contains("activate")) // Means that a poi has been activated/deactivated. Service is running. + return true; +// return AutomationService.getInstance() != null && AutomationService.getInstance().isRunning; + } + + return false; + } +} diff --git a/app/src/main/java/com/jens/automation2/CompensateCrappyAndroidPaths.java b/app/src/main/java/com/jens/automation2/CompensateCrappyAndroidPaths.java new file mode 100644 index 0000000..cbf2d62 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/CompensateCrappyAndroidPaths.java @@ -0,0 +1,371 @@ +package com.jens.automation2; + +import android.annotation.SuppressLint; +import android.content.ContentUris; +import android.content.Context; +import android.database.Cursor; +import android.net.Uri; +import android.os.Build; +import android.os.Environment; +import android.provider.DocumentsContract; +import android.provider.MediaStore; +import android.provider.OpenableColumns; +import android.text.TextUtils; +import android.util.Log; + +import java.io.File; +import java.io.FileOutputStream; +import java.io.InputStream; + +public class CompensateCrappyAndroidPaths +{ + private static Uri contentUri = null; + + /** + * Get a file path from a Uri. This will get the the path for Storage Access + * Framework Documents, as well as the _data field for the MediaStore and + * other file-based ContentProviders.
+ *
+ * Callers should check whether the path is local before assuming it + * represents a local file. + * + * @param context The context. + * @param uri The Uri to query. + */ + @SuppressLint("NewApi") + public static String getPath(final Context context, final Uri uri) { + // check here to KITKAT or new version + final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT; + String selection = null; + String[] selectionArgs = null; + // DocumentProvider + if (isKitKat && DocumentsContract.isDocumentUri(context, uri)) { + // ExternalStorageProvider + if (isExternalStorageDocument(uri)) { + final String docId = DocumentsContract.getDocumentId(uri); + final String[] split = docId.split(":"); + final String type = split[0]; + + String fullPath = getPathFromExtSD(split); + if (fullPath != "") { + return fullPath; + } else { + return null; + } + } + + // DownloadsProvider + else if (isDownloadsDocument(uri)) { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { + final String id; + Cursor cursor = null; + try { + cursor = context.getContentResolver().query(uri, new String[]{MediaStore.MediaColumns.DISPLAY_NAME}, null, null, null); + if (cursor != null && cursor.moveToFirst()) { + String fileName = cursor.getString(0); + String path = Environment.getExternalStorageDirectory().toString() + "/Download/" + fileName; + if (!TextUtils.isEmpty(path)) { + return path; + } + } + } finally { + if (cursor != null) + cursor.close(); + } + id = DocumentsContract.getDocumentId(uri); + if (!TextUtils.isEmpty(id)) { + if (id.startsWith("raw:")) { + return id.replaceFirst("raw:", ""); + } + String[] contentUriPrefixesToTry = new String[]{ + "content://downloads/public_downloads", + "content://downloads/my_downloads" + }; + for (String contentUriPrefix : contentUriPrefixesToTry) { + try { + final Uri contentUri = ContentUris.withAppendedId(Uri.parse(contentUriPrefix), Long.valueOf(id)); + + /* final Uri contentUri = ContentUris.withAppendedId( + Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));*/ + + return getDataColumn(context, contentUri, null, null); + } catch (NumberFormatException e) { + //In Android 8 and Android P the id is not a number + return uri.getPath().replaceFirst("^/document/raw:", "").replaceFirst("^raw:", ""); + } + } + + + } + + } else { + final String id = DocumentsContract.getDocumentId(uri); + final boolean isOreo = Build.VERSION.SDK_INT >= Build.VERSION_CODES.O; + if (id.startsWith("raw:")) { + return id.replaceFirst("raw:", ""); + } + try { + contentUri = ContentUris.withAppendedId( + Uri.parse("content://downloads/public_downloads"), Long.valueOf(id)); + + } catch (NumberFormatException e) { + e.printStackTrace(); + } + if (contentUri != null) { + return getDataColumn(context, contentUri, null, null); + } + } + + + } + // MediaProvider + else if (isMediaDocument(uri)) { + final String docId = DocumentsContract.getDocumentId(uri); + final String[] split = docId.split(":"); + final String type = split[0]; + + Uri contentUri = null; + + if ("image".equals(type)) { + contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI; + } else if ("video".equals(type)) { + contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI; + } else if ("audio".equals(type)) { + contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI; + } + selection = "_id=?"; + selectionArgs = new String[]{split[1]}; + + + return getDataColumn(context, contentUri, selection, + selectionArgs); + } else if (isGoogleDriveUri(uri)) { + return getDriveFilePath(uri, context); + } + } + + + // MediaStore (and general) + else if ("content".equalsIgnoreCase(uri.getScheme())) { + + if (isGooglePhotosUri(uri)) { + return uri.getLastPathSegment(); + } + + if (isGoogleDriveUri(uri)) { + return getDriveFilePath(uri, context); + } + if (Build.VERSION.SDK_INT == Build.VERSION_CODES.N) { + // return getFilePathFromURI(context,uri); + return getMediaFilePathForN(uri, context); + // return getRealPathFromURI(context,uri); + } else { + + return getDataColumn(context, uri, null, null); + } + + + } + // File + else if ("file".equalsIgnoreCase(uri.getScheme())) { + return uri.getPath(); + } + + return null; + } + + /** + * Check if a file exists on device + * + * @param filePath The absolute file path + */ + private static boolean fileExists(String filePath) { + File file = new File(filePath); + + return file.exists(); + } + + + /** + * Get full file path from external storage + * + * @param pathData The storage type and the relative path + */ + private static String getPathFromExtSD(String[] pathData) { + final String type = pathData[0]; + final String relativePath = "/" + pathData[1]; + String fullPath = ""; + + // on my Sony devices (4.4.4 & 5.1.1), `type` is a dynamic string + // something like "71F8-2C0A", some kind of unique id per storage + // don't know any API that can get the root path of that storage based on its id. + // + // so no "primary" type, but let the check here for other devices + if ("primary".equalsIgnoreCase(type)) { + fullPath = Environment.getExternalStorageDirectory() + relativePath; + if (fileExists(fullPath)) { + return fullPath; + } + } + + // Environment.isExternalStorageRemovable() is `true` for external and internal storage + // so we cannot relay on it. + // + // instead, for each possible path, check if file exists + // we'll start with secondary storage as this could be our (physically) removable sd card + fullPath = System.getenv("SECONDARY_STORAGE") + relativePath; + if (fileExists(fullPath)) { + return fullPath; + } + + fullPath = System.getenv("EXTERNAL_STORAGE") + relativePath; + if (fileExists(fullPath)) { + return fullPath; + } + + return fullPath; + } + + private static String getDriveFilePath(Uri uri, Context context) { + Uri returnUri = uri; + Cursor returnCursor = context.getContentResolver().query(returnUri, null, null, null, null); + /* + * Get the column indexes of the data in the Cursor, + * * move to the first row in the Cursor, get the data, + * * and display it. + * */ + int nameIndex = returnCursor.getColumnIndex(OpenableColumns.DISPLAY_NAME); + int sizeIndex = returnCursor.getColumnIndex(OpenableColumns.SIZE); + returnCursor.moveToFirst(); + String name = (returnCursor.getString(nameIndex)); + String size = (Long.toString(returnCursor.getLong(sizeIndex))); + File file = new File(context.getCacheDir(), name); + try { + InputStream inputStream = context.getContentResolver().openInputStream(uri); + FileOutputStream outputStream = new FileOutputStream(file); + int read = 0; + int maxBufferSize = 1 * 1024 * 1024; + int bytesAvailable = inputStream.available(); + + //int bufferSize = 1024; + int bufferSize = Math.min(bytesAvailable, maxBufferSize); + + final byte[] buffers = new byte[bufferSize]; + while ((read = inputStream.read(buffers)) != -1) { + outputStream.write(buffers, 0, read); + } + Log.e("File Size", "Size " + file.length()); + inputStream.close(); + outputStream.close(); + Log.e("File Path", "Path " + file.getPath()); + Log.e("File Size", "Size " + file.length()); + } catch (Exception e) { + Log.e("Exception", e.getMessage()); + } + return file.getPath(); + } + + private static String getMediaFilePathForN(Uri uri, Context context) { + Uri returnUri = uri; + Cursor returnCursor = context.getContentResolver().query(returnUri, null, null, null, null); + /* + * Get the column indexes of the data in the Cursor, + * * move to the first row in the Cursor, get the data, + * * and display it. + * */ + int nameIndex = returnCursor.getColumnIndex(OpenableColumns.DISPLAY_NAME); + int sizeIndex = returnCursor.getColumnIndex(OpenableColumns.SIZE); + returnCursor.moveToFirst(); + String name = (returnCursor.getString(nameIndex)); + String size = (Long.toString(returnCursor.getLong(sizeIndex))); + File file = new File(context.getFilesDir(), name); + try { + InputStream inputStream = context.getContentResolver().openInputStream(uri); + FileOutputStream outputStream = new FileOutputStream(file); + int read = 0; + int maxBufferSize = 1 * 1024 * 1024; + int bytesAvailable = inputStream.available(); + + //int bufferSize = 1024; + int bufferSize = Math.min(bytesAvailable, maxBufferSize); + + final byte[] buffers = new byte[bufferSize]; + while ((read = inputStream.read(buffers)) != -1) { + outputStream.write(buffers, 0, read); + } + Log.e("File Size", "Size " + file.length()); + inputStream.close(); + outputStream.close(); + Log.e("File Path", "Path " + file.getPath()); + Log.e("File Size", "Size " + file.length()); + } catch (Exception e) { + Log.e("Exception", e.getMessage()); + } + return file.getPath(); + } + + + private static String getDataColumn(Context context, Uri uri, + String selection, String[] selectionArgs) { + Cursor cursor = null; + final String column = "_data"; + final String[] projection = {column}; + + try { + cursor = context.getContentResolver().query(uri, projection, + selection, selectionArgs, null); + + if (cursor != null && cursor.moveToFirst()) { + final int index = cursor.getColumnIndexOrThrow(column); + return cursor.getString(index); + } + } finally { + if (cursor != null) + cursor.close(); + } + + return null; + } + + /** + * @param uri - The Uri to check. + * @return - Whether the Uri authority is ExternalStorageProvider. + */ + private static boolean isExternalStorageDocument(Uri uri) { + return "com.android.externalstorage.documents".equals(uri.getAuthority()); + } + + /** + * @param uri - The Uri to check. + * @return - Whether the Uri authority is DownloadsProvider. + */ + private static boolean isDownloadsDocument(Uri uri) { + return "com.android.providers.downloads.documents".equals(uri.getAuthority()); + } + + /** + * @param uri - The Uri to check. + * @return - Whether the Uri authority is MediaProvider. + */ + private static boolean isMediaDocument(Uri uri) { + return "com.android.providers.media.documents".equals(uri.getAuthority()); + } + + /** + * @param uri - The Uri to check. + * @return - Whether the Uri authority is Google Photos. + */ + private static boolean isGooglePhotosUri(Uri uri) { + return "com.google.android.apps.photos.content".equals(uri.getAuthority()); + } + + + /** + * @param uri The Uri to check. + * @return Whether the Uri authority is Google Drive. + */ + private static boolean isGoogleDriveUri(Uri uri) { + return "com.google.android.apps.docs.storage".equals(uri.getAuthority()) || "com.google.android.apps.docs.storage.legacy".equals(uri.getAuthority()); + } + +} diff --git a/app/src/main/java/com/jens/automation2/Miscellaneous.java b/app/src/main/java/com/jens/automation2/Miscellaneous.java new file mode 100644 index 0000000..1eadfc7 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/Miscellaneous.java @@ -0,0 +1,887 @@ +package com.jens.automation2; + +import android.annotation.SuppressLint; +import android.app.AlertDialog; +import android.app.Notification; +import android.app.NotificationChannel; +import android.app.NotificationManager; +import android.app.PendingIntent; +import android.app.Service; +import android.content.Context; +import android.content.DialogInterface; +import android.content.Intent; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager; +import android.database.Cursor; +import android.net.Uri; +import android.os.Build; +import android.os.Environment; +import android.os.IBinder; +import android.provider.MediaStore; +import android.provider.Settings.Secure; +import android.util.Base64; +import android.util.Log; +import android.widget.Toast; + +import androidx.core.app.NotificationCompat; + +import com.jens.automation2.location.LocationProvider; +import com.jens.automation2.receivers.PhoneStatusListener; + +import org.apache.http.HttpEntity; +import org.apache.http.HttpResponse; +import org.apache.http.HttpVersion; +import org.apache.http.client.HttpClient; +import org.apache.http.client.methods.HttpPost; +import org.apache.http.conn.ssl.SSLSocketFactory; +import org.apache.http.impl.client.DefaultHttpClient; +import org.apache.http.params.BasicHttpParams; +import org.apache.http.params.HttpParams; +import org.apache.http.params.HttpProtocolParams; +import org.apache.http.util.EntityUtils; + +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.lang.Thread.UncaughtExceptionHandler; +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.net.HttpURLConnection; +import java.net.URL; +import java.security.KeyManagementException; +import java.security.KeyStore; +import java.security.NoSuchAlgorithmException; +import java.security.cert.CertificateException; +import java.security.cert.X509Certificate; +import java.sql.Time; +import java.util.ArrayList; +import java.util.Calendar; +import java.util.Date; + +import javax.net.ssl.HostnameVerifier; +import javax.net.ssl.HttpsURLConnection; +import javax.net.ssl.SSLContext; +import javax.net.ssl.SSLSession; +import javax.net.ssl.TrustManager; +import javax.net.ssl.X509TrustManager; + +import static com.jens.automation2.AutomationService.NOTIFICATION_CHANNEL_ID; +import static com.jens.automation2.AutomationService.channelName; + +//import android.R.string; +//import android.util.Log; + +public class Miscellaneous extends Service +{ + private static String writeableFolderStringCache = null; + public static final String lineSeparator = System.getProperty("line.separator"); + + public static String downloadURL(String url, String username, String password) + { + HttpClient httpclient = new DefaultHttpClient(); + StringBuilder responseBody = new StringBuilder(); + boolean errorFound = false; + + try + { + try + { + URL urlObject = new URL(url); + HttpURLConnection connection; + + if(url.toLowerCase().contains("https")) + { + connection = (HttpsURLConnection) urlObject.openConnection(); + +// if(Settings.httpAcceptAllCertificates) +// { +// SSLContext sc = SSLContext.getInstance("TLS"); +// sc.init(null, getInsecureTrustManager(), new java.security.SecureRandom()); +// HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory()); +// Miscellaneous.disableSSLCertificateChecking(); +// HttpsURLConnection.setDefaultHostnameVerifier(getInsecureHostnameVerifier()); +// } + } + else + connection = (HttpURLConnection) urlObject.openConnection(); + + // Add http simple authentication if specified + if(username != null && password != null) + { + String encodedCredentials = Base64.encodeToString(new String(username + ":" + password).getBytes(), Base64.DEFAULT); + connection.setRequestMethod("POST"); + connection.setDoOutput(true); + connection.setRequestProperty ("Authorization", "Basic " + encodedCredentials); + } + + InputStream content = (InputStream)connection.getInputStream(); + BufferedReader in = new BufferedReader (new InputStreamReader (content)); + String line; + while ((line = in.readLine()) != null) + responseBody.append(line + Miscellaneous.lineSeparator); + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "HTTP error", Log.getStackTraceString(e), 3); + errorFound = true; + } + } + finally + { + // When HttpClient instance is no longer needed, + // shut down the connection manager to ensure + // immediate deallocation of all system resources + httpclient.getConnectionManager().shutdown(); + if(errorFound) + return "httpError"; + else + return responseBody.toString(); + } + } + + public static String downloadURLwithoutCertificateChecking(String url, String username, String password) + { +// HttpClient httpclient = new DefaultHttpClient(); +// StringBuilder responseBody = new StringBuilder(); + boolean errorFound = false; + + try + { + HttpParams params = new BasicHttpParams(); + params.setParameter(HttpProtocolParams.USE_EXPECT_CONTINUE, false); + HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); + HttpClient httpclient = new DefaultHttpClient(params); + httpclient = Actions.getInsecureSslClient(httpclient); + + HttpPost httppost = new HttpPost(url); + + // Add http simple authentication if specified + if(username != null && password != null) + { + String encodedCredentials = Base64.encodeToString(new String(username + ":" + password).getBytes(), Base64.DEFAULT); +// List nameValuePairs = new ArrayList(1); + httppost.addHeader("Authorization", "Basic " + encodedCredentials); +// nameValuePairs.add(new BasicNameValuePair("Authorization", "Basic " + encodedCredentials)); +// httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs, "UTF-8")); + } + + HttpResponse response = httpclient.execute(httppost); + HttpEntity entity = response.getEntity(); + if (entity != null) + { +// System.out.println(EntityUtils.toString(entity)); + return EntityUtils.toString(entity); + } + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "HTTP error", Log.getStackTraceString(e), 3); + errorFound = true; + return "httpError"; + } +// finally +// { +// // When HttpClient instance is no longer needed, +// // shut down the connection manager to ensure +// // immediate deallocation of all system resources +// httpclient.getConnectionManager().shutdown(); +// return responseBody.toString(); +// } + + return null; + } + + @Override + public IBinder onBind(Intent arg0) + { + // TODO Auto-generated method stub + return null; + } + +// public static void logEvent(String type, String header, String description) +// { +// if(type.equals("e")) +// Log.e(header, description); +// +// if(type.equals("w")) +// Log.w(header, description); +// +// if(type.equals("i")) +// Log.i(header, description); +// +// if(Settings.writeLogFile) +// writeToLogFile(type, header, description); +// } + + public static void logEvent(String type, String header, String description, int logLevel) + { + try + { + header = getAnyContext().getResources().getString(R.string.app_name); + } + catch(NullPointerException e) + { + header = "Automation"; + } + + if(type.equals("e")) + Log.e(header, description); + + if(type.equals("w")) + Log.w(header, description); + + if(type.equals("i")) + Log.i(header, description); + + if(Settings.writeLogFile && Settings.logLevel >= logLevel) + { + writeToLogFile(type, header, description); + + if(!logCleanerRunning && Math.random() < 0.1) // tidy up with 10% probability + { + rotateLogFile(getLogFile()); + } + } + } + + protected static boolean logCleanerRunning = false; + protected static void rotateLogFile(File logFile) + { + logCleanerRunning = true; + + + long maxSizeInBytes = (long)Settings.logFileMaxSize * 1024 * 1024; + + if(logFile.exists() && logFile.length() > (maxSizeInBytes)) + { + Miscellaneous.logEvent("i", "Logfile", "Cleaning up log file.", 3); + File archivedLogFile = new File(getWriteableFolder() + "/" + logFileName + "-old"); + logFile.renameTo(archivedLogFile); + Miscellaneous.logEvent("i", "Logfile", "Cleaning up log file finished. Old log renamed to " + archivedLogFile.getAbsolutePath(), 3); + } + + logCleanerRunning = false; + } + + protected static boolean testFolder(String folderPath) + { + File folder = new File(folderPath + "/" + Settings.folderName); + final String testFileName = "AutomationTestFile.txt"; + + try + { + if(folder.exists() || folder.mkdirs()) + { + XmlFileInterface.migrateFilesFromRootToFolder(folderPath, folder.getAbsolutePath()); + + File testFile = new File(folder + "/" + testFileName); + if(!testFile.exists()) + testFile.createNewFile(); + + if(testFile.canRead() && testFile.canWrite()) + { + testFile.delete(); + writeableFolderStringCache = testFile.getParent(); + Miscellaneous.logEvent("i", "File", "Test of " + folder.getAbsolutePath() + " succeeded.", 3); + return true; + } + } + } + catch (IOException e) + { + e.printStackTrace(); + } + + Miscellaneous.logEvent("w", "File", "Test of " + folder.getAbsolutePath() + " failed.", 3); + return false; + } + + public static String getWriteableFolder() + { + if(writeableFolderStringCache == null) + { + String testPath = null; + File folder = null; + + try + { + String[] foldersToTestArray = new String[] + { + Environment.getExternalStorageDirectory().getAbsolutePath(), + "/storage/emulated/0", + "/HWUserData", + "/mnt/sdcard" + }; + + for(String f : foldersToTestArray) + { + if (testFolder(f)) + { + String pathToUse = f + "/" + Settings.folderName; + Miscellaneous.logEvent("i", "Path", "Using " + pathToUse + " to store settings and log.", 2); +// Toast.makeText(getAnyContext(), "Using " + pathToUse + " to store settings and log.", Toast.LENGTH_LONG).show(); + return pathToUse; + } + else + Miscellaneous.logEvent("e", "getWritableFolder", folder.getAbsolutePath() + " does not exist and could not be created.", 3); + } + } + catch(Exception e) + { + Log.w("getWritableFolder", folder + " not writable."); + } + + // do not change to logEvent() - we can't write + Toast.makeText(getAnyContext(), "No writable folder could be found.", Toast.LENGTH_LONG).show(); + Log.e("getWritableFolder", "No writable folder could be found."); + + return null; + } + else + return writeableFolderStringCache; + } + + protected final static String logFileName = "Automation_logfile.txt"; + protected static File getLogFile() + { + File logFile = null; + logFile = new File(getWriteableFolder() + "/" + logFileName); + if(!logFile.exists()) + { + Log.i("LogFile", "Creating new logfile: " + logFile.getAbsolutePath()); + try + { + logFile.createNewFile(); + } + catch(Exception e) + { + Log.e("LogFile", "Error writing logs to file: " + e.getMessage()); + } + } + + return logFile; + } + private static void writeToLogFile(String type, String header, String description) + { + try + { + FileWriter fileWriter = new FileWriter(getLogFile(), true); + BufferedWriter bufferedWriter = new BufferedWriter(fileWriter); + Date date = new Date(); + + bufferedWriter.write("\n" + date + ": " + type + " / " + header + " / " + description); + bufferedWriter.close(); + +// Log.i("LogFile", "Log entry written."); + } + catch(Exception e) + { + Log.e("LogFile", "Error writing logs to file: " + e.getMessage()); + } + } + + public static boolean isAndroidEmulator() + { + String TAG = "EmulatorTest"; + String model = Build.MODEL; +// Miscellaneous.logEvent("i", TAG, "model=" + model); + String product = Build.PRODUCT; +// Miscellaneous.logEvent("i", TAG, "product=" + product); + boolean isEmulator = false; + if (product != null) + { + isEmulator = product.equals("sdk") || product.contains("_sdk") || product.contains("sdk_"); + } +// Miscellaneous.logEvent("i", TAG, "isEmulator=" + isEmulator); + return isEmulator; + } + + public static int compareTimes(Time time1, Time time2) + { +// Miscellaneous.logEvent("i", "TimeCompare", "To compare: " + time1.toString() + " / " + time2.toString()); + + if(time1.getHours() == time2.getHours() && time1.getMinutes() == time2.getMinutes()) + { +// Miscellaneous.logEvent("i", "TimeCompare", "Times are equal."); + return 0; + } + + if(time1.getHours() > time2.getHours()) + { +// Miscellaneous.logEvent("i", "TimeCompare", "Time1 is bigger/later by hours."); + return -1; + } + + if(time1.getHours() < time2.getHours()) + { +// Miscellaneous.logEvent("i", "TimeCompare", "Time2 is bigger/later by hours."); + return 1; + } + + if(time1.getHours() == time2.getHours()) + { + if(time1.getMinutes() < time2.getMinutes()) + { +// Miscellaneous.logEvent("i", "TimeCompare", "Hours are equal. Time2 is bigger/later by minutes."); + return 1; + } + + if(time1.getMinutes() > time2.getMinutes()) + { +// Miscellaneous.logEvent("i", "TimeCompare", "Hours are equal. Time1 is bigger/later by minutes."); + return -1; + } + } + + + Miscellaneous.logEvent("i", "TimeCompare", "Default return code. Shouldn't be here.", 5); + return 0; + + } + + public static String convertStreamToString(InputStream is) + { + java.util.Scanner s = new java.util.Scanner(is).useDelimiter("\\A"); + return s.hasNext() ? s.next() : ""; + } + + public static Context getAnyContext() + { + Context returnContext; + + returnContext = AutomationService.getInstance(); + if(returnContext != null) + return returnContext; + + returnContext = ActivityMainScreen.getActivityMainScreenInstance(); + if(returnContext != null) + return returnContext; + + returnContext = ActivityPermissions.getInstance().getApplicationContext(); + if(returnContext != null) + return returnContext; + + return null; + } + + @SuppressLint("NewApi") + public static String replaceVariablesInText(String source, Context context) throws Exception + { + // Replace variable with actual content +// Miscellaneous.logEvent("i", "Raw source", source); + if(source.contains("[uniqueid]")) + source = source.replace("[uniqueid]", Secure.getString(context.getContentResolver(), Secure.ANDROID_ID)); + + if(source.contains("[latitude]") | source.contains("[longitude]")) + { + if(LocationProvider.getLastKnownLocation() != null) + { + source = source.replace("[latitude]", String.valueOf(LocationProvider.getLastKnownLocation().getLatitude())); + source = source.replace("[longitude]", String.valueOf(LocationProvider.getLastKnownLocation().getLongitude())); + } + else + { + Miscellaneous.logEvent("w", "TriggerURL", context.getResources().getString(R.string.triggerUrlReplacementPositionError), 3); + } + } + + if(source.contains("[phonenr]")) + { + String lastPhoneNr = PhoneStatusListener.getLastPhoneNumber(); + + if(lastPhoneNr != null && lastPhoneNr.length() > 0) + source = source.replace("[phonenr]", PhoneStatusListener.getLastPhoneNumber()); + else + Miscellaneous.logEvent("w", "TriggerURL", context.getResources().getString(R.string.triggerUrlReplacementPositionError), 3); + } + + if(source.contains("[serialnr]")) + if(Build.VERSION.SDK_INT > 8) + source = source.replace("[serialnr]", Secure.getString(context.getContentResolver(), Build.SERIAL)); + else + source = source.replace("[serialnr]", "serialUnknown"); + + if( + source.contains("[d]") | + source.contains("[m]") | + source.contains("[Y]") | + source.contains("[h]") | + source.contains("[H]") | + source.contains("[i]") | + source.contains("[s]") | + source.contains("[ms]") + ) + { + Calendar cal = Calendar.getInstance(); + + source = source.replace("[d]", String.valueOf(cal.get(Calendar.DAY_OF_MONTH))); + source = source.replace("[m]", String.valueOf(cal.get(Calendar.MONTH))); + source = source.replace("[Y]", String.valueOf(cal.get(Calendar.YEAR))); + source = source.replace("[h]", String.valueOf(cal.get(Calendar.HOUR))); + source = source.replace("[H]", String.valueOf(cal.get(Calendar.HOUR_OF_DAY))); + source = source.replace("[i]", String.valueOf(cal.get(Calendar.MINUTE))); + source = source.replace("[s]", String.valueOf(cal.get(Calendar.SECOND))); + source = source.replace("[ms]", String.valueOf(cal.get(Calendar.MILLISECOND))); + } + +// Miscellaneous.logEvent("i", "URL after replace", source); + + return source; + } + + /** + * Write a log entry and exit the application, so the crash is actually visible. + * Might even cause the activity to be automatically restarted by the OS. + */ + public static UncaughtExceptionHandler uncaughtExceptionHandler = new UncaughtExceptionHandler() + { + @Override + public void uncaughtException(Thread thread, Throwable ex) + { + Miscellaneous.logEvent("e", "UncaughtException", Log.getStackTraceString(ex), 1); + System.exit(0); + } + }; + + public static AlertDialog messageBox(String title, String message, Context context) + { + AlertDialog.Builder alertDialog = new AlertDialog.Builder(context); + + alertDialog.setTitle(title); + alertDialog.setMessage(message); + + alertDialog.setPositiveButton("Ok", new DialogInterface.OnClickListener() + { + public void onClick(DialogInterface dialog, int whichButton) + { + dialog.dismiss(); + } + }); + +// alertDialog.setNegativeButton(context.getResources().getString(R.string.cancel), new DialogInterface.OnClickListener() +// { +// public void onClick(DialogInterface dialog, int whichButton) +// { +// // Canceled. +// } +// }); + + return alertDialog.create(); + } + + /** + * Checks if the device is rooted. + * + * @return true if the device is rooted, false otherwise. + */ + public static boolean isPhoneRooted() + { + // get from build info + String buildTags = Build.TAGS; + if (buildTags != null && buildTags.contains("test-keys")) { + return true; + } + + // check if /system/app/Superuser.apk is present + try + { + File file = new File("/system/app/Superuser.apk"); + if (file.exists()) + { + return true; + } + } + catch (Exception e1) + { + // ignore + } + + // try executing commands + return canExecuteCommand("/system/xbin/which su") + || + canExecuteCommand("/system/bin/which su") + || + canExecuteCommand("which su"); + } + + // executes a command on the system + private static boolean canExecuteCommand(String command) + { + boolean executedSuccesfully; + try + { + Runtime.getRuntime().exec(command); + executedSuccesfully = true; + } + catch (Exception e) + { + executedSuccesfully = false; + } + + return executedSuccesfully; + } + + public static boolean isNumeric(String str) + { + return str.matches("-?\\d+(\\.\\d+)?"); //match a number with optional '-' and decimal. + } + + /** + * Disables the SSL certificate checking for new instances of {@link HttpsURLConnection} This has been created to + * aid testing on a local box, not for use on production. + */ + private static void disableSSLCertificateChecking() + { + try + { + SSLSocketFactory ssf = null; + + try + { + SSLContext ctx = SSLContext.getInstance("TLS"); + + KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType()); + trustStore.load(null, null); + ssf = new MySSLSocketFactoryInsecure(trustStore); + ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); + ctx.init(null, null, null); + +// return new DefaultHttpClient(ccm, client.getParams()); + } + catch (Exception ex) + { + ex.printStackTrace(); +// return null; + } + + // Install the all-trusting trust manager + SSLContext sc = SSLContext.getInstance("TLS"); + sc.init(null, getInsecureTrustManager(), new java.security.SecureRandom()); +// HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory()); +// HttpsURLConnection.setDefaultSSLSocketFactory(ssf); + + // Install the all-trusting host verifier + HttpsURLConnection.setDefaultHostnameVerifier(getInsecureHostnameVerifier()); + HttpsURLConnection.setDefaultHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); + } + catch (KeyManagementException e) + { + // TODO Auto-generated catch block + e.printStackTrace(); + } + catch (NoSuchAlgorithmException e) + { + // TODO Auto-generated catch block + e.printStackTrace(); + } + finally + { + + } + } + + public static TrustManager[] getInsecureTrustManager() + { + TrustManager[] trustAllCerts = + new TrustManager[] + { + new X509TrustManager() + { + public X509Certificate[] getAcceptedIssuers() + { + return null; + } + + @Override + public void checkClientTrusted(X509Certificate[] arg0, String arg1) throws CertificateException + { + // Not implemented + } + + @Override + public void checkServerTrusted(X509Certificate[] arg0, String arg1) throws CertificateException + { + // Not implemented + } + } + }; + + return trustAllCerts; + } + + public static HostnameVerifier getInsecureHostnameVerifier() + { + HostnameVerifier allHostsValid = new HostnameVerifier() + { + public boolean verify(String hostname, SSLSession session) + { + return true; + } + }; + + return allHostsValid; + } + + @SuppressLint("NewApi") + @SuppressWarnings("deprecation") + public static void createDismissableNotification(String textToDisplay, int notificationId, PendingIntent pendingIntent) + { + NotificationManager mNotificationManager = (NotificationManager) Miscellaneous.getAnyContext().getSystemService(Context.NOTIFICATION_SERVICE); + + NotificationCompat.Builder dismissableNotificationBuilder = createDismissableNotificationBuilder(pendingIntent); + dismissableNotificationBuilder.setContentText(textToDisplay); + dismissableNotificationBuilder.setContentIntent(pendingIntent); + dismissableNotificationBuilder.setStyle(new NotificationCompat.BigTextStyle().bigText(textToDisplay)); + + Notification dismissableNotification = dismissableNotificationBuilder.build(); + + mNotificationManager.notify(notificationId, dismissableNotification); + + /*NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this) + .setSmallIcon(R.drawable.ic_launcher) // notification icon + .setContentTitle("Notification!") // title for notification + .setContentText("Hello word") // message for notification + .setAutoCancel(true); // clear notification after click + Intent intent = new Intent(this, MainActivity.class); + PendingIntent pi = PendingIntent.getActivity(this,0,intent,Intent.FLAG_ACTIVITY_NEW_TASK); + mBuilder.setContentIntent(pi); + NotificationManager mNotificationManager = + (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE); + mNotificationManager.notify(0, dismissableNotification);*/ + } + + /*protected static Notification.Builder createDismissableNotificationBuilder() + { + Notification.Builder builder = new Notification.Builder(AutomationService.getInstance()); + builder.setContentTitle("Automation"); + builder.setSmallIcon(R.drawable.ic_launcher); + builder.setCategory(Notification.CATEGORY_EVENT); + builder.setWhen(System.currentTimeMillis()); + + //static PendingIntent myPendingIntent = PendingIntent.getActivity(this, 0, myIntent, 0); + + //builder.setContentIntent(myPendingIntent); + +// Notification defaultNotification = new Notification(); +*//* Notification defaultNotification = builder.build(); + + defaultNotification.icon = R.drawable.ic_launcher; + defaultNotification.when = System.currentTimeMillis(); + +// defaultNotification.defaults |= Notification.DEFAULT_VIBRATE; +// defaultNotification.defaults |= Notification.DEFAULT_LIGHTS; + + defaultNotification.flags |= Notification.FLAG_AUTO_CANCEL; +// defaultNotification.flags |= Notification.FLAG_SHOW_LIGHTS; + defaultNotification.flags |= Notification.FLAG_ONLY_ALERT_ONCE; + +// defaultNotification.ledARGB = Color.YELLOW; +// defaultNotification.ledOnMS = 1500; +// defaultNotification.ledOffMS = 1500; +*//* + return builder; + }*/ + + protected static NotificationCompat.Builder createDismissableNotificationBuilder(PendingIntent myPendingIntent) + { + NotificationManager mNotificationManager = (NotificationManager) AutomationService.getInstance().getSystemService(Context.NOTIFICATION_SERVICE); + + NotificationCompat.Builder builder; + + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) + { + NotificationChannel chan = new NotificationChannel(NOTIFICATION_CHANNEL_ID, channelName, NotificationManager.IMPORTANCE_LOW); +// chan.setLightColor(Color.BLUE); +// chan.enableVibration(false); +// chan.setSound(null, null); + chan.setLockscreenVisibility(Notification.VISIBILITY_PRIVATE); + mNotificationManager.createNotificationChannel(chan); + + builder = new NotificationCompat.Builder(AutomationService.getInstance(), NOTIFICATION_CHANNEL_ID); + } + else + builder = new NotificationCompat.Builder(AutomationService.getInstance()); + + if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) + builder.setCategory(Notification.CATEGORY_SERVICE); + + builder.setWhen(System.currentTimeMillis()); + builder.setContentIntent(myPendingIntent); + + builder.setContentTitle(AutomationService.getInstance().getResources().getString(R.string.app_name)); +// builder.setOnlyAlertOnce(true); + + builder.setSmallIcon(R.drawable.priority); + +// builder.setContentText(textToDisplay); +// builder.setSmallIcon(icon); +// builder.setStyle(new NotificationCompat.BigTextStyle().bigText(textToDisplay)); + + return builder; + } + + public static String explode(ArrayList arrayList) + { + StringBuilder builder = new StringBuilder(); + for(String s : arrayList) + builder.append(s); + + return builder.toString(); + } + + public static boolean isGooglePlayInstalled(Context context) + { +// return false; + PackageManager pm = context.getPackageManager(); + boolean app_installed = false; + try + { + PackageInfo info = pm.getPackageInfo("com.android.vending", PackageManager.GET_ACTIVITIES); + String label = (String) info.applicationInfo.loadLabel(pm); + app_installed = (label != null && !label.equals("Market")); + } + catch (PackageManager.NameNotFoundException e) + { + app_installed = false; + } + return app_installed; + } + + public static double round(double value, int places) + { + if (places < 0) throw new IllegalArgumentException(); + + BigDecimal bd = new BigDecimal(Double.toString(value)); + bd = bd.setScale(places, RoundingMode.HALF_UP); + return bd.doubleValue(); + } + + public static String getRealPathFromURI(Context context, Uri contentUri) + { + Cursor cursor = null; + try + { + String[] proj = { MediaStore.Images.Media.DATA }; + cursor = context.getContentResolver().query(contentUri, proj, null, null, null); + int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA); + cursor.moveToFirst(); + return cursor.getString(column_index); + } + catch (Exception e) + { + Miscellaneous.logEvent("e", "Uri", "getRealPathFromURI Exception : " + Log.getStackTraceString(e), 1); + return null; + } + finally + { + if (cursor != null) + { + cursor.close(); + } + } + } +} \ No newline at end of file diff --git a/app/src/main/java/com/jens/automation2/MyHttpClient.java b/app/src/main/java/com/jens/automation2/MyHttpClient.java new file mode 100644 index 0000000..6005b1a --- /dev/null +++ b/app/src/main/java/com/jens/automation2/MyHttpClient.java @@ -0,0 +1,57 @@ +package com.jens.automation2; + +import android.content.Context; + +import org.apache.http.conn.ClientConnectionManager; +import org.apache.http.conn.scheme.PlainSocketFactory; +import org.apache.http.conn.scheme.Scheme; +import org.apache.http.conn.scheme.SchemeRegistry; +import org.apache.http.conn.ssl.SSLSocketFactory; +import org.apache.http.impl.client.DefaultHttpClient; +import org.apache.http.impl.conn.SingleClientConnManager; + +import java.security.KeyStore; + +public class MyHttpClient extends DefaultHttpClient +{ + + final Context context; + + public MyHttpClient(Context context) + { + this.context = context; + } + + @Override + protected ClientConnectionManager createClientConnectionManager() + { + SchemeRegistry registry = new SchemeRegistry(); + registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); + // Register for port 443 our SSLSocketFactory with our keystore + // to the ConnectionManager + registry.register(new Scheme("https", newSslSocketFactory(), 443)); + return new SingleClientConnManager(getParams(), registry); + } + + private SSLSocketFactory newSslSocketFactory() + { + try + { + // Get an instance of the Bouncy Castle KeyStore format + KeyStore trusted = KeyStore.getInstance("BKS"); + // Get the raw resource, which contains the keystore with + // your trusted certificates (root and any intermediate certs) + // Pass the keystore to the SSLSocketFactory. The factory is responsible + // for the verification of the server certificate. + SSLSocketFactory sf = new SSLSocketFactory(trusted); + // Hostname verification from certificate + // http://hc.apache.org/httpcomponents-client-ga/tutorial/html/connmgmt.html#d4e506 + sf.setHostnameVerifier(SSLSocketFactory.STRICT_HOSTNAME_VERIFIER); + return sf; + } + catch (Exception e) + { + throw new AssertionError(e); + } + } +} \ No newline at end of file diff --git a/app/src/main/java/com/jens/automation2/MySSLSocketFactoryInsecure.java b/app/src/main/java/com/jens/automation2/MySSLSocketFactoryInsecure.java new file mode 100644 index 0000000..2a5ebfb --- /dev/null +++ b/app/src/main/java/com/jens/automation2/MySSLSocketFactoryInsecure.java @@ -0,0 +1,57 @@ +package com.jens.automation2; + +import org.apache.http.conn.ssl.SSLSocketFactory; + +import java.io.IOException; +import java.net.Socket; +import java.net.UnknownHostException; +import java.security.KeyManagementException; +import java.security.KeyStore; +import java.security.KeyStoreException; +import java.security.NoSuchAlgorithmException; +import java.security.UnrecoverableKeyException; +import java.security.cert.CertificateException; +import java.security.cert.X509Certificate; + +import javax.net.ssl.SSLContext; +import javax.net.ssl.TrustManager; +import javax.net.ssl.X509TrustManager; + +public class MySSLSocketFactoryInsecure extends SSLSocketFactory +{ + SSLContext sslContext = SSLContext.getInstance("TLS"); + + public MySSLSocketFactoryInsecure(KeyStore truststore) throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException { + super(truststore); + + TrustManager tm = new X509TrustManager() + { + public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException + { + } + + public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException + { + } + + public X509Certificate[] getAcceptedIssuers() + { + return null; + } + }; + + sslContext.init(null, new TrustManager[] { tm }, null); + } + + @Override + public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException, UnknownHostException + { + return sslContext.getSocketFactory().createSocket(socket, host, port, autoClose); + } + + @Override + public Socket createSocket() throws IOException + { + return sslContext.getSocketFactory().createSocket(); + } +} \ No newline at end of file diff --git a/app/src/main/java/com/jens/automation2/PointOfInterest.java b/app/src/main/java/com/jens/automation2/PointOfInterest.java new file mode 100644 index 0000000..5f1b0ec --- /dev/null +++ b/app/src/main/java/com/jens/automation2/PointOfInterest.java @@ -0,0 +1,825 @@ +package com.jens.automation2; + +import android.content.Context; +import android.location.Criteria; +import android.location.Location; +import android.location.LocationListener; +import android.location.LocationManager; +import android.os.Bundle; +import android.os.Handler; +import android.os.Message; +import android.util.Log; +import android.widget.Toast; + +import com.jens.automation2.Trigger.Trigger_Enum; + +import java.io.FileNotFoundException; +import java.util.ArrayList; +import java.util.Collections; + +public class PointOfInterest implements Comparable +{ + // The array containing all POIs + private static ArrayList pointOfInterestCollection = new ArrayList(); + + public static ArrayList getPointOfInterestCollection() + { + Collections.sort(pointOfInterestCollection); + return pointOfInterestCollection; + } + + public static void setPointOfInterestCollection(ArrayList pointOfInterestCollection) + { + Collections.sort(pointOfInterestCollection); + PointOfInterest.pointOfInterestCollection = pointOfInterestCollection; + } + + // name and location + private String name; + private Location location; + private double radius; + + private String oldName; + private boolean activated=false; + + private static Location[] locationRingBuffer = new Location[Settings.locationRingBufferSize]; + private static int locationRingBufferLastPosition = -1; + + private static boolean gpsLocationListenerArmed = false; + private static LocationManager gpsComparisonLocationManager; + private static GpsComparisonLocationListener gpsComparisonLocationListener; + private static TimeoutHandler timeoutHandler = new TimeoutHandler(); + private static boolean timeoutHandlerActive = false; + public String getName() + { + return name; + } + + public static void stopRoutine() + { + if(gpsLocationListenerArmed) + stopGpsMeasurement(); + } + + public void setName(String desiredName) + { + this.oldName = this.name; + this.name = desiredName; + } + + public Location getLocation() + { + return location; + } + + public void setLocation(Location location) + { + this.location = location; + } + + public double getRadius() + { + return radius; + } + + public void setRadius(double radius, Context context) throws Exception + { + if(radius <= 0) + throw new Exception(context.getResources().getString(R.string.radiusHasToBePositive)); + + this.radius = radius; + } + + public void setActivated(boolean value) + { + this.activated = value; + } + public boolean isActivated() + { + return activated; + } + + public static void positionUpdate(Location newLocation, AutomationService parentService, boolean forceApply, boolean skipVerfication) + { +// StackTraceElement[] trace = Thread.currentThread().getStackTrace(); +// for(StackTraceElement element : trace) +// { +// Log.i("Trace", Arrays.toString(trace)); +// } + + // Assumption "active POI = closest POI" is wrong! + + if(newLocation != null) + { + String accuracyString = "n./a."; + if(newLocation.hasAccuracy()) + accuracyString = String.valueOf(newLocation.getAccuracy() + " m"); + Miscellaneous.logEvent("i", "POI", "Got position update (" + String.valueOf(newLocation.getLatitude()) + " / " + String.valueOf(newLocation.getLongitude()) + " / provider: " + newLocation.getProvider() + " / Accuracy: " + accuracyString + "), checking rules.", 2); + + PointOfInterest closestPoi = PointOfInterest.getClosestPOI(newLocation); + + if(getActivePoi() != null) + Miscellaneous.logEvent("i", "POI", "Active POI: " + getActivePoi().getName() + ", distance : " + String.valueOf(newLocation.distanceTo(getActivePoi().getLocation())), 4); + + if(closestPoi == null) + { + // There are no POIs defined. Not much we can do. + // Miscellaneous.logEvent("i", "POI", "Closest POI: n/a, distance : n/a", 4); + Miscellaneous.logEvent("i", "POI", "Got position update, but there are no POIs defined. Can't trigger a rule.", 3); + // return; + } + else + Miscellaneous.logEvent("i", "POI", "Closest POI: " + closestPoi.getName() + ", distance : " + String.valueOf(newLocation.distanceTo(closestPoi.getLocation())), 4); + + if( + (getActivePoi() != null && getActivePoi().isActivated() && !getActivePoi().reachedPoiArea(newLocation)) + | + (closestPoi != null && !closestPoi.isActivated() && closestPoi.reachedPoiArea(newLocation)) + ) + { + // only an active POI can be left while only a closestPOI can be entered, hence the complex if/else + if(getActivePoi() != null && getActivePoi().isActivated() && !getActivePoi().reachedPoiArea(newLocation)) + Miscellaneous.logEvent("i", "POI", "May have left POI " + getActivePoi().getName() + ", checking location accuracy...", 4); + if(closestPoi != null && !closestPoi.isActivated() && closestPoi.reachedPoiArea(newLocation)) + Miscellaneous.logEvent("i", "POI", "May have entered POI " + closestPoi.getName() + ", checking location accuracy...", 4); + + if(forceApply) + { + Miscellaneous.logEvent("i", parentService.getResources().getString(R.string.forcedLocationUpdate), parentService.getResources().getString(R.string.forcedLocationUpdateLong), 4); + + // only an active POI can be left while only a closestPOI can be entered, hence the complex if/else + if(getActivePoi() != null && getActivePoi().isActivated() && !getActivePoi().reachedPoiArea(newLocation)) + { + addPositionToRingBuffer(newLocation); + getActivePoi().deactivate(parentService); + } + if(closestPoi != null && !closestPoi.isActivated() && closestPoi.reachedPoiArea(newLocation)) + { + addPositionToRingBuffer(newLocation); + closestPoi.activate(parentService); + } + } + else if(newLocation.hasAccuracy() && newLocation.getAccuracy() > Settings.satisfactoryAccuracyNetwork && !newLocation.getProvider().equals(LocationManager.GPS_PROVIDER)) + { + Miscellaneous.logEvent("i", "POI", "Location update with unsatisfactory accuracy: " + String.valueOf(newLocation.getAccuracy()) + ", demanded: " + String.valueOf(Settings.satisfactoryAccuracyNetwork), 4); + if(!skipVerfication) + { + if(PointOfInterest.isPoiInRelevantRange(newLocation)) + startGpsMeasurement(parentService); + else + { + Miscellaneous.logEvent("i", "POI", "Applying update with unsatisfactory accuracy because no defined location is in a relevant range.", 4); + positionUpdate(newLocation, parentService, true, false); + } + } + else + { + Miscellaneous.logEvent("i", "POI", "Location update with unsatisfactory accuracy, but skipping verfication as requested. Effectively ignoring this update. It's probably from a passive source. Verifying it would cost battery.", 4); + } + } + else + { + Miscellaneous.logEvent("i", "POI", "Location update with acceptable accuracy.", 4); + /* It may be that a previous location wasn't accurate enough, we now got a better location via network, + * but the GPS listener is still active and trying to find out a precise location. We need to deactivate + * it if we are here + */ + if(gpsLocationListenerArmed) + stopGpsMeasurement(); + + // only an active POI can be left while only a closestPOI can be entered, hence the complex if/else + if(getActivePoi() != null && getActivePoi().isActivated() && !getActivePoi().reachedPoiArea(newLocation)) + { + addPositionToRingBuffer(newLocation); + getActivePoi().deactivate(parentService); + } + if(closestPoi != null && !closestPoi.isActivated() && closestPoi.reachedPoiArea(newLocation)) + { + addPositionToRingBuffer(newLocation); + closestPoi.activate(parentService); + } + } + } + } + else + Miscellaneous.logEvent("e", "POI", "Given location is null. Aborting.", 3); + } + + public Boolean reachedPoiArea(Location currentLocation) + { + float distance = this.location.distanceTo(currentLocation); + + if(distance < this.radius) + { + return true; + } + else + { + return false; + } + } + + public void activate(AutomationService parentService) + { + if(!this.isActivated()) + { + // Deactivate all others in case nobody deactivated them + for(int i = 0; i < pointOfInterestCollection.size(); i++) + pointOfInterestCollection.get(i).deactivate(parentService); + + /* + ConcurrentModificationErrors have been seen when using this method: for(PointOfInterest onePoi : pointOfInterestCollection) + + Tue Nov 20 19:21:50 GMT+01:00 2018: e / Automation / java.util.ConcurrentModificationException + at java.util.ArrayList$Itr.next(ArrayList.java:860) + at com.jens.automation2.PointOfInterest.activate(PointOfInterest.java:227) + at com.jens.automation2.PointOfInterest.positionUpdate(PointOfInterest.java:199) + at com.jens.automation2.location.LocationProvider.setCurrentLocation(LocationProvider.java:126) + at com.jens.automation2.location.LocationProvider$MyPassiveLocationListener.onLocationChanged(LocationProvider.java:289) + at android.location.LocationManager$ListenerTransport._handleMessage(LocationManager.java:291) + at android.location.LocationManager$ListenerTransport.-wrap0(Unknown Source:0) + at android.location.LocationManager$ListenerTransport$1.handleMessage(LocationManager.java:236) + at android.os.Handler.dispatchMessage(Handler.java:105) + at android.os.Looper.loop(Looper.java:164) + at android.app.ActivityThread.main(ActivityThread.java:6944) + at java.lang.reflect.Method.invoke(Native Method) + at com.android.internal.os.Zygote$MethodAndArgsCaller.run(Zygote.java:327) + at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:1374) + */ + + this.activated = true; + Settings.lastActivePoi = this; + Settings.writeSettings(parentService); + + Miscellaneous.logEvent("i", "POI", "Reached POI " + this.getName() + ". Checking if there's a rule that applies to that.", 2); + + ArrayList ruleCandidates = Rule.findRuleCandidatesByPoi(this, true); + if(ruleCandidates.size()==0) + { + Miscellaneous.logEvent("i", "POI", "POI " + this.getName() + " not found in ANY rule.", 2); + } + else + { + Miscellaneous.logEvent("i", "POI", "POI " + this.getName() + " found in " + ruleCandidates.size() + " rule(s).", 2); + + for(int i=0; i ruleCandidates = Rule.findRuleCandidatesByPoi(this, false); + if(ruleCandidates.size()==0) + { + Miscellaneous.logEvent("i", "POI", "POI " + this.getName() + " not found in ANY rule.", 2); + } + else + { + Miscellaneous.logEvent("i", "POI", "POI " + this.getName() + " found in " + ruleCandidates.size() + " rule(s).", 2); + for(int i=0; i 1) + { + Toast.makeText(context, context.getResources().getString(R.string.anotherPoiByThatName), Toast.LENGTH_LONG).show(); + return false; + } + + // Check if rules reference this poi + ArrayList rulesThatReferenceMe = Rule.findRuleCandidatesByPoi(this); + if (rulesThatReferenceMe.size() > 0) + { + for (Rule oneRule : rulesThatReferenceMe) + { + for (Trigger oneTrigger : oneRule.getTriggerSet()) + { + if (oneTrigger.getTriggerType() == Trigger_Enum.pointOfInterest) + { + oneTrigger.setPointOfInterest(this); + // We don't need to save the file. This will happen anyway in PointOfInterest.writePoisToFile() below. + } + } + } + } + } + /* + Check for change of rule name END + */ + + if (plausibilityCheck()) + { + if(PointOfInterest.writePoisToFile()) + { + AutomationService service = AutomationService.getInstance(); + if (service != null) + { + service.applySettingsAndRules(); + //Easiest way to check for changes in location, reset the last known location. + service.getLocationProvider().setCurrentLocation(service.getLocationProvider().getCurrentLocation(), true); + } + + return true; + } + else + return false; + } + } + catch(Exception e) + { + Toast.makeText(context, context.getResources().getString(R.string.unknownError), Toast.LENGTH_LONG).show(); + } + + return false; + } + public boolean delete(Context context) + { + //Check if there's a rule that contains this poi + ArrayList rulesThatReferenceMe = Rule.findRuleCandidatesByPoi(this); + if(rulesThatReferenceMe.size() > 0) + { + String rulesString = ""; + for(Rule rule : rulesThatReferenceMe) + rulesString += rule.getName() + "; "; + + rulesString = rulesString.substring(0, rulesString.length()-2); + + Toast.makeText(context, String.format(context.getResources().getString(R.string.poiStillReferenced), rulesString), Toast.LENGTH_LONG).show(); + return false; + } + else + { + PointOfInterest.pointOfInterestCollection.remove(this); + PointOfInterest.writePoisToFile(); + + AutomationService service = AutomationService.getInstance(); + if(service != null) + { + service.applySettingsAndRules(); + + //Easiest way to check for changes in location, reset the last known location. + service.getLocationProvider().setCurrentLocation(service.getLocationProvider().getCurrentLocation(), true); + } + + + return true; + } + } + + public static PointOfInterest getByName(String searchName) throws Exception + { + for(PointOfInterest poi : pointOfInterestCollection) + { + if(poi.name.equals(searchName)) + return poi; + } + + throw new Exception("PointOfInterest with name " + searchName + " not found."); + } + + public static String[] getNamesInArray() + { + ArrayList nameList = new ArrayList(); + for(PointOfInterest poi : pointOfInterestCollection) + { + nameList.add(poi.name); + } + + return (String[])nameList.toArray(new String[pointOfInterestCollection.size()]); + } + + public static PointOfInterest getActivePoi() + { + for(PointOfInterest poi : PointOfInterest.pointOfInterestCollection) + { + if(poi.isActivated()) + return poi; + } + + return null; + } + + @Override + public int compareTo(PointOfInterest another) + { + return this.getName().compareTo(another.getName()); + } + + private static boolean addPositionToRingBuffer(Location newLocation) + { + /* + * This method's purpose is to record the last n positions and check if they are different. + * In reality you will never get the exact same position twice. If you do the location engine + * seems to have hung up. + */ + + try + { + if(++locationRingBufferLastPosition > locationRingBuffer.length-1) + locationRingBufferLastPosition = 0; + + Miscellaneous.logEvent("i", "Ringbuffer.", "Adding location " + String.valueOf(newLocation.getLatitude()) + " / " + String.valueOf(newLocation.getLongitude()) + " to ringbuffer at index " + String.valueOf(locationRingBufferLastPosition), 5); + locationRingBuffer[locationRingBufferLastPosition] = newLocation; + + /* + * Return values: + * true if the new location is different to the last one + * false if we get repeated values, comparing all values + * + * false indicates problems with hangups in getting locations. + */ + + int counter = locationRingBufferLastPosition+1-1; // make a copy, not a reference + int previousIndex; + do + { + if(counter>0) + previousIndex = counter-1; + else + previousIndex = Settings.locationRingBufferSize-1; + + try + { + if(locationRingBuffer[counter].getLatitude() != locationRingBuffer[previousIndex].getLatitude() | locationRingBuffer[counter].getLongitude() != locationRingBuffer[previousIndex].getLongitude()) + { + // If location different from last one we're fine. + Miscellaneous.logEvent("w", "Ringbuffer.", "Location has changed from the last one. We\'re fine.", 5); + return true; + } + } + catch(NullPointerException ne) + { + /* + * Just null pointer exception. Ringbuffer isn't filled to its maximum, yet. + */ + return true; + } + + if(counter>0) + counter--; + else + counter = Settings.locationRingBufferSize-1; + } while(counter != locationRingBufferLastPosition); + + Miscellaneous.logEvent("w", "Ringbuffer", "Location has not changed from the last one. Something\'s odd. Maybe the location engine kind of hung up.", 2); + return false; + } + catch(ArrayIndexOutOfBoundsException e) + { + Miscellaneous.logEvent("e", "Ringbuffer", "Probably not enough values, yet.", 5); + return true; + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "Ringbuffer", "Error in ringbuffer: " + Log.getStackTraceString(e), 4); + return true; + } + } + + public static class GpsComparisonLocationListener implements LocationListener + { + public AutomationService parent = null; + + @Override + public void onLocationChanged(Location up2DateLocation) + { + stopGpsMeasurement(); + + PointOfInterest.positionUpdate(up2DateLocation, parent, true, false); + + Miscellaneous.logEvent("i", "LocationListener", "Disarmed location listener, accuracy reached", 4); + } + + @Override + public void onProviderDisabled(String provider) + { + // TODO Auto-generated method stub + + } + + @Override + public void onProviderEnabled(String provider) + { + // TODO Auto-generated method stub + + } + + @Override + public void onStatusChanged(String provider, int status, Bundle extras) + { + // TODO Auto-generated method stub + + } + } + + private static void startGpsMeasurement(AutomationService parentService) + { + // Arm location updates + if(!gpsLocationListenerArmed) + { + Miscellaneous.logEvent("i", "PointOfInterest", "Unsatisfactory accuracy of network location. Performing comparison measurement via GPS.", 3); + + String myGpsComparisonProviderName; + + if(Settings.privacyLocationing) + { + Miscellaneous.logEvent("i", "PointOfInterest", parentService.getResources().getString(R.string.enforcingGps), 4); + myGpsComparisonProviderName = LocationManager.GPS_PROVIDER; + } + else + { +// Miscellaneous.logEvent("i", "PointOfInterest", parentService.getResources().getString(R.string.notEnforcingGps), 4); + Criteria crit = new Criteria(); + // crit.setPowerRequirement(Criteria.POWER_LOW); + // crit.setAltitudeRequired(false); + // crit.setSpeedRequired(false); + // crit.setBearingRequired(false); + crit.setCostAllowed(true); + crit.setAccuracy(Criteria.ACCURACY_FINE); + gpsComparisonLocationManager = (LocationManager)parentService.getSystemService(parentService.LOCATION_SERVICE); + myGpsComparisonProviderName = gpsComparisonLocationManager.getBestProvider(crit, true); + } + + Miscellaneous.logEvent("i", "LocationListener", "Arming location listener, Provider: " + myGpsComparisonProviderName, 4); + gpsComparisonLocationListener = new GpsComparisonLocationListener(); + gpsComparisonLocationListener.parent = parentService; + gpsComparisonLocationManager.requestLocationUpdates(myGpsComparisonProviderName, Settings.minimumTimeBetweenUpdate, Settings.minimumDistanceChangeForNetworkUpdate, gpsComparisonLocationListener); + gpsLocationListenerArmed = true; + + // set timeout + Message message = new Message(); + message.what = 1; + Miscellaneous.logEvent("i", parentService.getResources().getString(R.string.gpsComparison), parentService.getResources().getString(R.string.startingGpsTimeout), 4); + if(timeoutHandler.parentService == null) + timeoutHandler.parentService = parentService; + timeoutHandler.sendMessageDelayed(message, Settings.gpsTimeout * 1000); + timeoutHandlerActive = true; + } + else + Miscellaneous.logEvent("i", "PointOfInterest", "Comparison measurement via GPS requested, but already active.", 3); + } + + private static void stopGpsMeasurement() + { + if(gpsLocationListenerArmed) + { + gpsComparisonLocationManager.removeUpdates(gpsComparisonLocationListener); + gpsLocationListenerArmed = false; + } + + if(timeoutHandlerActive) + { + timeoutHandler.removeMessages(1); + timeoutHandlerActive = false; + } + + } + + private static class TimeoutHandler extends Handler + { + public AutomationService parentService = null; + public Location locationToApplyIfGpsFails = null; + + @Override + public void handleMessage(Message msg) + { + super.handleMessage(msg); + + if(msg.what == 1) + { + Miscellaneous.logEvent("i", parentService.getResources().getString(R.string.gpsComparison), parentService.getResources().getString(R.string.gpsComparisonTimeoutStop), 4); + stopGpsMeasurement(); + } + } + } + + private boolean plausibilityCheck() + { + double distance, minimumDistance, overlap; + + if(this.getName().equals("null")) + { + // Invalid name + String text = Miscellaneous.getAnyContext().getResources().getString(R.string.invalidPoiName); + Miscellaneous.logEvent("w", "POI", text, 2); + Toast.makeText(Miscellaneous.getAnyContext(), text, Toast.LENGTH_LONG).show(); + return false; + } + + for(PointOfInterest otherPoi : this.getPointOfInterestCollection()) + { + distance = otherPoi.getLocation().distanceTo(this.getLocation()); + minimumDistance = otherPoi.getRadius()/2 + this.getRadius()/2; + overlap = Math.round(Math.abs(distance - minimumDistance)); + + if(distance <= minimumDistance && !otherPoi.getName().equals(this.getName())) + { + String text = String.format(Miscellaneous.getAnyContext().getResources().getString(R.string.overlapBetweenPois), otherPoi.getName(), String.valueOf(overlap)); + Miscellaneous.logEvent("w", "POI", text, 2); + Toast.makeText(Miscellaneous.getAnyContext(), text, Toast.LENGTH_LONG).show(); + return false; + } + } + Miscellaneous.logEvent("w", "POI", Miscellaneous.getAnyContext().getResources().getString(R.string.noOverLap), 2); + + return true; + } + + public static boolean reachedPoiWithActivateWifiRule() + { + PointOfInterest activePoi = PointOfInterest.getActivePoi(); + if(activePoi != null) + { + for(Rule rule : Rule.findRuleCandidatesByPoi(activePoi, true)) + { + for(Action action : rule.getActionSet()) + { + if(action.getAction().equals(Action.Action_Enum.setWifi) && action.getParameter1()) + { + // We are at a POI that specifies to enable wifi. + return true; + } + } + } + } + + return false; + } +} \ No newline at end of file diff --git a/app/src/main/java/com/jens/automation2/Profile.java b/app/src/main/java/com/jens/automation2/Profile.java new file mode 100644 index 0000000..821c390 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/Profile.java @@ -0,0 +1,543 @@ +package com.jens.automation2; + +import android.content.ContentValues; +import android.content.Context; +import android.media.AudioManager; +import android.media.RingtoneManager; +import android.net.Uri; +import android.provider.MediaStore; +import android.util.Log; +import android.widget.Toast; + +import com.jens.automation2.Action.Action_Enum; + +import java.io.File; +import java.util.ArrayList; + +public class Profile implements Comparable +{ + protected static ArrayList profileCollection = new ArrayList(); + + protected String name; + protected String oldName; + + protected boolean changeSoundMode; + protected int soundMode; + + boolean changeVolumeMusicVideoGameMedia; + protected int volumeMusic; + + protected boolean changeVolumeNotifications; + protected int volumeNotifications; + + protected boolean changeVolumeAlarms; + protected int volumeAlarms; + + protected boolean changeIncomingCallsRingtone; + protected File incomingCallsRingtone; + + protected boolean changeVibrateWhenRinging; + protected boolean vibrateWhenRinging; + + protected boolean changeNotificationRingtone; + protected File notificationRingtone; + + protected boolean changeAudibleSelection; + protected boolean audibleSelection; + + protected boolean changeScreenLockUnlockSound; + boolean screenLockUnlockSound; + + protected boolean changeHapticFeedback; + protected boolean hapticFeedback; + + + public void setName(String name) + { + this.oldName = this.name; + this.name = name; + } + + public String getName() + { + return name; + } + + public void setChangeSoundMode(boolean changeSoundMode) + { + this.changeSoundMode = changeSoundMode; + } + public boolean getChangeSoundMode() + { + return changeSoundMode; + } + + public void setSoundMode(int soundMode) + { + this.soundMode = soundMode; + } + public int getSoundMode() + { + return soundMode; + } + + public void setChangeVolumeMusicVideoGameMedia(boolean changeVolumeMusicVideoGameMedia) + { + this.changeVolumeMusicVideoGameMedia = changeVolumeMusicVideoGameMedia; + } + public boolean getChangeVolumeMusicVideoGameMedia() + { + return changeVolumeMusicVideoGameMedia; + } + + public void setVolumeMusic(int volumeMusic) + { + this.volumeMusic = volumeMusic; + } + public int getVolumeMusic() + { + return volumeMusic; + } + + public void setChangeVolumeNotifications(boolean changeVolumeRingtoneNotifications) + { + this.changeVolumeNotifications = changeVolumeRingtoneNotifications; + } + public boolean getChangeVolumeNotifications() + { + return changeVolumeNotifications; + } + + public void setVolumeNotifications(int volumeNotifications) + { + this.volumeNotifications = volumeNotifications; + } + public int getVolumeNotifications() + { + return volumeNotifications; + } + + public void setChangeVolumeAlarms(boolean changeVolumeAlarms) + { + this.changeVolumeAlarms = changeVolumeAlarms; + } + public boolean getChangeVolumeAlarms() + { + return changeVolumeAlarms; + } + + public void setVolumeAlarms(int volumeAlarms) + { + this.volumeAlarms = volumeAlarms; + } + public int getVolumeAlarms() + { + return volumeAlarms; + } + + public void setChangeIncomingCallsRingtone(boolean changeIncomingCallsRingtone) + { + this.changeIncomingCallsRingtone = changeIncomingCallsRingtone; + } + public boolean getChangeIncomingCallsRingtone() + { + return changeIncomingCallsRingtone; + } + + public void setIncomingCallsRingtone(File incomingCallsRingtone) + { + this.incomingCallsRingtone = incomingCallsRingtone; + } + public File getIncomingCallsRingtone() + { + return incomingCallsRingtone; + } + + public void setChangeVibrateWhenRinging(boolean changeVibrateWhenRinging) + { + this.changeVibrateWhenRinging = changeVibrateWhenRinging; + } + public boolean getChangeVibrateWhenRinging() + { + return changeVibrateWhenRinging; + } + + public void setVibrateWhenRinging(boolean vibrateWhenRinging) + { + this.vibrateWhenRinging = vibrateWhenRinging; + } + public boolean getVibrateWhenRinging() + { + return vibrateWhenRinging; + } + + public void setChangeNotificationRingtone(boolean changeNotificationRingtone) + { + this.changeNotificationRingtone = changeNotificationRingtone; + } + public boolean getChangeNotificationRingtone() + { + return changeNotificationRingtone; + } + + public void setNotificationRingtone(File notificationsRingtone) + { + this.notificationRingtone = notificationsRingtone; + } + public File getNotificationRingtone() + { + return notificationRingtone; + } + + public void setChangeAudibleSelection(boolean changeAudibleSelection) + { + this.changeAudibleSelection = changeAudibleSelection; + } + public boolean getChangeAudibleSelection() + { + return changeAudibleSelection; + } + + public void setAudibleSelection(boolean audibleSelection) + { + this.audibleSelection = audibleSelection; + } + public boolean getAudibleSelection() + { + return audibleSelection; + } + + public void setChangeScreenLockUnlockSound(boolean changeScreenLockUnlockSound) + { + this.changeScreenLockUnlockSound = changeScreenLockUnlockSound; + } + public boolean getChangeScreenLockUnlockSound() + { + return changeScreenLockUnlockSound; + } + + public void setScreenLockUnlockSound(boolean screenLockUnlockSound) + { + this.screenLockUnlockSound = screenLockUnlockSound; + } + public boolean getScreenLockUnlockSound() + { + return screenLockUnlockSound; + } + + public void setChangeHapticFeedback(boolean changeHapticFeedback) + { + this.changeHapticFeedback = changeHapticFeedback; + } + public boolean getChangeHapticFeedback() + { + return changeHapticFeedback; + } + + public void setHapticFeedback(boolean hapticFeedback) + { + this.hapticFeedback = hapticFeedback; + } + public boolean getHapticFeedback() + { + return hapticFeedback; + } + + public static ArrayList getProfileCollection() + { + return profileCollection; + } + public static ArrayList getProfileCollectionString() + { + ArrayList returnList = new ArrayList(); + for(Profile p : profileCollection) + returnList.add(p.getName()); + + return returnList; + } + + public static Profile getByName(String name) + { + for(Profile p : Profile.getProfileCollection()) + if(p.getName().equals(name)) + return p; + + return null; + } + + public boolean delete(AutomationService myAutomationService) + { + // TODO Auto-generated method stub + return false; + } + + private boolean applyRingTone(File ringtoneFile, int ringtoneType, Context context) + { + Miscellaneous.logEvent("i", "Profile", "Request to set ringtone to " + ringtoneFile.getAbsolutePath(), 3); + + if(!ringtoneFile.exists() | !ringtoneFile.canRead()) + { + String message = "Ringtone file does not exist or cannot read it: " + ringtoneFile.getAbsolutePath(); + Miscellaneous.logEvent("i", "Profile", message, 3); + Toast.makeText(context, message, Toast.LENGTH_SHORT).show(); + return false; + } + + ContentValues values = new ContentValues(); + values.put(MediaStore.MediaColumns.DATA, ringtoneFile.getAbsolutePath()); +// values.put(MediaStore.MediaColumns.TITLE, context.getResources().getString(R.string.app_name) + " ringtone"); +// values.put(MediaStore.MediaColumns.TITLE, ringtoneFile.getName().replace(".mp3", "").replace(".", "")); + values.put(MediaStore.MediaColumns.TITLE, ringtoneFile.getName()); +// values.put(MediaStore.MediaColumns.MIME_TYPE, "audio/*"); + values.put(MediaStore.MediaColumns.MIME_TYPE, "audio/mp3"); + values.put(MediaStore.MediaColumns.SIZE, ringtoneFile.length()); +// values.put(MediaStore.Audio.Media.ARTIST, R.string.app_name); + values.put(MediaStore.Audio.Media.IS_RINGTONE, ringtoneType == RingtoneManager.TYPE_RINGTONE); + values.put(MediaStore.Audio.Media.IS_NOTIFICATION, ringtoneType == RingtoneManager.TYPE_NOTIFICATION); + values.put(MediaStore.Audio.Media.IS_ALARM, false); + values.put(MediaStore.Audio.Media.IS_MUSIC, false); + + Uri existingRingTone = MediaStore.Audio.Media.getContentUriForPath(ringtoneFile.getAbsolutePath()); + if(existingRingTone != null) + context.getContentResolver().delete(existingRingTone, MediaStore.MediaColumns.DATA + "=\"" + ringtoneFile.getAbsolutePath() + "\"", null); + Uri newRingTone = context.getContentResolver().insert(existingRingTone, values); + + try + { + RingtoneManager.setActualDefaultRingtoneUri(context, ringtoneType, newRingTone); + Miscellaneous.logEvent("i", "Profile", "Ringtone set to: " + newRingTone.toString(), 1); +// Ringtone tone = RingtoneManager.getRingtone(context, RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)); +// tone.play(); + return true; + } + catch (Throwable t) + { + String message = "Error setting ringtone: " + Log.getStackTraceString(t); + Miscellaneous.logEvent("e", "Profile", message, 1); + } + + return false; + } + + public boolean create(Context context, boolean writeToFile) + { + for(Profile profile : Profile.profileCollection) + { + if (profile.getName().equals(this.getName())) + { + Toast.makeText(context, context.getResources().getString(R.string.anotherProfileByThatName), Toast.LENGTH_LONG).show(); + return false; + } + } + + if(plausibilityCheck()) + { + // add to collection + Profile.getProfileCollection().add(this); + + // write to file + if(writeToFile) + return XmlFileInterface.writeFile(); + } + + return false; + } + + public boolean change(Context context) + { + if(this.oldName != null && !this.oldName.equals(this.name)) + { + //Name has changed. We need to look for rules that reference it by its name and update those references + + // Check if the name is still available + int counter = 0; // this method should only be a temporary workaround, directly editing the referenced object may cause problems until reloading the config file + for(Profile profile : Profile.profileCollection) + { + if (profile.getName().equals(this.getName())) + { + counter++; + } + } + + if(counter > 1) + { + Toast.makeText(context, context.getResources().getString(R.string.anotherProfileByThatName), Toast.LENGTH_LONG).show(); + return false; + } + + // Check if rules reference this profile + ArrayList rulesThatReferenceMe = Rule.findRuleCandidatesByProfile(this); + if(rulesThatReferenceMe.size() > 0) + { + for(Rule oneRule : rulesThatReferenceMe) + { + for(Action oneAction : oneRule.getActionSet()) + { + if(oneAction.getAction() == Action_Enum.changeSoundProfile) + { + oneAction.setParameter2(this.name); + // We don't need to save the file. This will happen anyway in PointOfInterest.writePoisToFile() below. + } + } + } + } + } + + if(plausibilityCheck()) + { + // write to file + if(XmlFileInterface.writeFile()) + { + AutomationService service = AutomationService.getInstance(); + if(service != null) + service.applySettingsAndRules(); + + return true; + } + } + + return false; + } + + public boolean delete() + { + for(int i = 0; i< Profile.getProfileCollection().size(); i++) + { + if(Profile.getProfileCollection().get(i).getName().equals(this.getName())) + { + Profile.getProfileCollection().remove(0); + + // write to file + return XmlFileInterface.writeFile(); + } + } + + return false; + } + + private boolean plausibilityCheck() + { + if(this.getName().equals("null")) + { + // Invalid name + String text = Miscellaneous.getAnyContext().getResources().getString(R.string.invalidProfileName); + Miscellaneous.logEvent("w", "Profile", text, 2); + Toast.makeText(Miscellaneous.getAnyContext(), text, Toast.LENGTH_LONG).show(); + return false; + } + + return true; + } + + @Override + public int compareTo(Profile another) + { + return this.getName().compareTo(another.getName()); + } + + public void activate(Context context) + { + Miscellaneous.logEvent("i", "Profile " + this.getName(), String.format(context.getResources().getString(R.string.profileActivate), this.getName()), 3); + + AutomationService.getInstance().checkLockSoundChangesTimeElapsed(); + + if(AutomationService.getInstance().getLockSoundChangesEnd() == null) + { + try + { + AudioManager am = (AudioManager) Miscellaneous.getAnyContext().getSystemService(Context.AUDIO_SERVICE); + + if(changeSoundMode) + Actions.setSound(context, soundMode); + + if(changeVolumeMusicVideoGameMedia) + am.setStreamVolume(AudioManager.STREAM_MUSIC, volumeMusic, AudioManager.FLAG_PLAY_SOUND); + + if(changeVolumeNotifications) + am.setStreamVolume(AudioManager.STREAM_NOTIFICATION, volumeNotifications, AudioManager.FLAG_PLAY_SOUND); + + if(changeVolumeAlarms) + am.setStreamVolume(AudioManager.STREAM_ALARM, volumeAlarms, AudioManager.FLAG_PLAY_SOUND); + + if(changeIncomingCallsRingtone) + if(incomingCallsRingtone != null) + applyRingTone(incomingCallsRingtone, RingtoneManager.TYPE_RINGTONE, context); + + if(changeVibrateWhenRinging) + if(vibrateWhenRinging) + am.setVibrateSetting(AudioManager.VIBRATE_TYPE_RINGER, AudioManager.VIBRATE_SETTING_ON); + else + am.setVibrateSetting(AudioManager.VIBRATE_TYPE_RINGER, AudioManager.VIBRATE_SETTING_OFF); + + if(changeNotificationRingtone) + if(notificationRingtone != null) + applyRingTone(notificationRingtone, RingtoneManager.TYPE_NOTIFICATION, context); + + if(changeScreenLockUnlockSound) + { + android.provider.Settings.System.putInt(context.getContentResolver(), "lockscreen_sounds_enabled" , screenLockUnlockSound ? 1 : 0); + } + + if(changeAudibleSelection) + { + if(audibleSelection) + android.provider.Settings.System.putInt(context.getContentResolver(), android.provider.Settings.System.SOUND_EFFECTS_ENABLED, 1); // enable + else + android.provider.Settings.System.putInt(context.getContentResolver(), android.provider.Settings.System.SOUND_EFFECTS_ENABLED, 0); // dissable + } + + if(changeHapticFeedback) + { + if(hapticFeedback) + android.provider.Settings.System.putInt(context.getContentResolver(), android.provider.Settings.System.HAPTIC_FEEDBACK_ENABLED, 1); // enable + else + android.provider.Settings.System.putInt(context.getContentResolver(), android.provider.Settings.System.HAPTIC_FEEDBACK_ENABLED, 0); // disable + } + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "Profile " + this.getName(), context.getResources().getString(R.string.errorActivatingProfile) + " " + Log.getStackTraceString(e), 1); + } + } + else + { + Miscellaneous.logEvent("i", "Profile " + this.getName(), context.getResources().getString(R.string.noProfileChangeSoundLocked), 3); + } + } + + @Override + public String toString() + { + return this.getName(); + } + + public String toStringLong() + { + return "no implemented, yet"; + } + + public static boolean createDummyProfile(Context context, String tagContent) + { + Profile newProfile = new Profile(); + + newProfile.setName(tagContent); + newProfile.setChangeSoundMode(true); + + if(tagContent.equals("silent")) + newProfile.setSoundMode(AudioManager.RINGER_MODE_SILENT); + else if(tagContent.equals("vibrate")) + newProfile.setSoundMode(AudioManager.RINGER_MODE_VIBRATE); + else if(tagContent.equals("normal")) + newProfile.setSoundMode(AudioManager.RINGER_MODE_NORMAL); + else + return false; + + return newProfile.create(context, false); + } + + public String getOldName() + { + return this.oldName; + } + +} diff --git a/app/src/main/java/com/jens/automation2/ReceiverCoordinator.java b/app/src/main/java/com/jens/automation2/ReceiverCoordinator.java new file mode 100644 index 0000000..f831ce9 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/ReceiverCoordinator.java @@ -0,0 +1,277 @@ +package com.jens.automation2; + +import android.util.Log; + +import com.jens.automation2.location.CellLocationChangedReceiver; +import com.jens.automation2.location.WifiBroadcastReceiver; +import com.jens.automation2.receivers.ActivityDetectionReceiver; +import com.jens.automation2.receivers.AlarmListener; +import com.jens.automation2.receivers.AutomationListenerInterface; +import com.jens.automation2.receivers.BatteryReceiver; +import com.jens.automation2.receivers.BluetoothReceiver; +import com.jens.automation2.receivers.ConnectivityReceiver; +import com.jens.automation2.receivers.HeadphoneJackListener; +import com.jens.automation2.receivers.NoiseListener; +import com.jens.automation2.receivers.PhoneStatusListener; +import com.jens.automation2.receivers.ProcessListener; +import com.jens.automation2.receivers.TimeZoneListener; + +/** + * Created by jens on 08.03.2017. + */ + +public class ReceiverCoordinator +{ + /* + * This class will manage getting the device's location. It will utilize the following methods: + * - CellLocationListener + * - WifiListener + * - Accelerometer + */ + + public static final Class[] allImplementers = { + ActivityDetectionReceiver.class, + AlarmListener.class, + BatteryReceiver.class, + BluetoothReceiver.class, + ConnectivityReceiver.class, + HeadphoneJackListener.class, + //NfcReceiver.class, + NoiseListener.class, + PhoneStatusListener.class, + ProcessListener.class, + TimeZoneListener.class + }; + + private static AutomationListenerInterface[] listeners = null; + + public static void startAllReceivers() + { + /* + * New procedure: + * Save instances of Listeners in ArrayList and run them. + */ + try + { + if(listeners == null) + { + listeners = new AutomationListenerInterface[allImplementers.length]; + int i = 0; + for(Class c : allImplementers) + { + try + { + listeners[i] = (AutomationListenerInterface) c.newInstance(); + + // UNCOMMENT THE NEXT LINE WHEN THIS PART OF THE CODE GOES ONLINE +// listeners[i].startListener(AutomationService.getInstance()); + } + catch (InstantiationException e) + { + e.printStackTrace(); + } + catch (IllegalAccessException e) + { + e.printStackTrace(); + } + finally + { + i++; + } + } + } + for(AutomationListenerInterface listener : listeners) + { + if(listener != null && listener.getMonitoredTrigger() != null) + { + String jobDescription = ""; + for (Trigger.Trigger_Enum name : listener.getMonitoredTrigger()) + jobDescription += name + ", "; + jobDescription = jobDescription.substring(0, jobDescription.length() - 2); + Miscellaneous.logEvent("i", "Listener", "Listener instance: " + listener.getClass().getName() + ", monitoring: " + jobDescription, 5); + } + } + } + catch(Exception e) + { + Miscellaneous.logEvent("w", "Error in new model", Log.getStackTraceString(e), 3); + } + +// if(Settings.useAccelerometerForPositioning && !Miscellaneous.isAndroidEmulator()) +// { +// accelerometerHandler = new AccelerometerHandler(); +// mySensorActivity = new SensorActivity(this); +// } + + // startPhoneStateListener + PhoneStatusListener.startPhoneStatusListener(AutomationService.getInstance()); // also used to mute anouncements during calls + + // startConnectivityReceiver + ConnectivityReceiver.startConnectivityReceiver(AutomationService.getInstance()); + + // startCellLocationChangedReceiver + if(!ConnectivityReceiver.isAirplaneMode(AutomationService.getInstance()) && WifiBroadcastReceiver.mayCellLocationReceiverBeActivated() && (Rule.isAnyRuleUsing(Trigger.Trigger_Enum.pointOfInterest) | Rule.isAnyRuleUsing(Trigger.Trigger_Enum.speed))) + CellLocationChangedReceiver.startCellLocationChangedReceiver(); + + // startBatteryReceiver + if(Rule.isAnyRuleUsing(Trigger.Trigger_Enum.charging) | Rule.isAnyRuleUsing(Trigger.Trigger_Enum.usb_host_connection) | Rule.isAnyRuleUsing(Trigger.Trigger_Enum.batteryLevel)) + BatteryReceiver.startBatteryReceiver(AutomationService.getInstance()); + + // startAlarmListener + AlarmListener.startAlarmListener(AutomationService.getInstance()); + TimeZoneListener.startTimeZoneListener(AutomationService.getInstance()); + + // startNoiseListener + if(Rule.isAnyRuleUsing(Trigger.Trigger_Enum.noiseLevel)) + NoiseListener.startNoiseListener(AutomationService.getInstance()); + + // startNoiseListener + if(Rule.isAnyRuleUsing(Trigger.Trigger_Enum.process_started_stopped)) + ProcessListener.startProcessListener(AutomationService.getInstance()); + + //startActivityDetectionReceiver + if(Rule.isAnyRuleUsing(Trigger.Trigger_Enum.activityDetection)) + ActivityDetectionReceiver.startActivityDetectionReceiver(); + + //startBluetoothReceiver + if(Rule.isAnyRuleUsing(Trigger.Trigger_Enum.bluetoothConnection)) + BluetoothReceiver.startBluetoothReceiver(); + + //startHeadsetJackListener + if(Rule.isAnyRuleUsing(Trigger.Trigger_Enum.headsetPlugged)) + HeadphoneJackListener.getInstance().startListener(AutomationService.getInstance()); + } + + public static void stopAllReceivers() + { + try + { + PhoneStatusListener.stopPhoneStatusListener(AutomationService.getInstance()); + ConnectivityReceiver.stopConnectivityReceiver(); + WifiBroadcastReceiver.stopWifiReceiver(); + BatteryReceiver.stopBatteryReceiver(); + TimeZoneListener.stopTimeZoneListener(); + AlarmListener.stopAlarmListener(AutomationService.getInstance()); + NoiseListener.stopNoiseListener(); + ProcessListener.stopProcessListener(AutomationService.getInstance()); + ActivityDetectionReceiver.stopActivityDetectionReceiver(); + BluetoothReceiver.stopBluetoothReceiver(); + HeadphoneJackListener.getInstance().stopListener(AutomationService.getInstance()); + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "cellReceiver", "Error stopping LocationReceiver: " + Log.getStackTraceString(e), 3); + } + } + + public static void applySettingsAndRules() + { + /* + * This method's purpose is to check settings and rules and determine + * if changes in them require monitors to be started or stopped. + * It takes care only of those which are more expensive. + */ + + // TextToSpeech is handled in AutomationService class + + Miscellaneous.logEvent("i", "LocationProvider", AutomationService.getInstance().getResources().getString(R.string.applyingSettingsAndRules), 3); + + // *********** RULE CHANGES *********** + + // timeFrame -> too inexpensive to shutdown + + if(Rule.isAnyRuleUsing(Trigger.Trigger_Enum.charging) | Rule.isAnyRuleUsing(Trigger.Trigger_Enum.usb_host_connection) | Rule.isAnyRuleUsing(Trigger.Trigger_Enum.batteryLevel)) + { + if(BatteryReceiver.haveAllPermission()) + BatteryReceiver.startBatteryReceiver(AutomationService.getInstance()); + } + else + BatteryReceiver.stopBatteryReceiver(); + + if(Rule.isAnyRuleUsing(Trigger.Trigger_Enum.noiseLevel)) + { + Miscellaneous.logEvent("i", "LocationProvider", "Starting NoiseListener because used in a new/changed rule.", 4); + if(NoiseListener.haveAllPermission()) + NoiseListener.startNoiseListener(AutomationService.getInstance()); + } + else + { + Miscellaneous.logEvent("i", "LocationProvider", "Shutting down NoiseListener because not used in any rule.", 4); + NoiseListener.stopNoiseListener(); + } + + if(Rule.isAnyRuleUsing(Trigger.Trigger_Enum.process_started_stopped)) + { + Miscellaneous.logEvent("i", "LocationProvider", "Starting ProcessListener because used in a new/changed rule.", 4); + if(ProcessListener.haveAllPermission()) + ProcessListener.startProcessListener(AutomationService.getInstance()); + } + else + { + Miscellaneous.logEvent("i", "LocationProvider", "Shutting down ProcessListener because not used in any rule.", 4); + ProcessListener.stopProcessListener(AutomationService.getInstance()); + } + + if(Rule.isAnyRuleUsing(Trigger.Trigger_Enum.activityDetection)) + { + if(ActivityDetectionReceiver.isActivityDetectionReceiverRunning()) + { + Miscellaneous.logEvent("i", "LocationProvider", "Restarting ActivityDetectionReceiver because used in a new/changed rule.", 4); + if(ActivityDetectionReceiver.haveAllPermission()) + ActivityDetectionReceiver.restartActivityDetectionReceiver(); + } + else + { + Miscellaneous.logEvent("i", "LocationProvider", "Starting ActivityDetectionReceiver because used in a new/changed rule.", 4); + if(ActivityDetectionReceiver.haveAllPermission()) + ActivityDetectionReceiver.startActivityDetectionReceiver(); + } + } + else + { + if(ActivityDetectionReceiver.isActivityDetectionReceiverRunning()) + { + Miscellaneous.logEvent("i", "LocationProvider", "Shutting down ActivityDetectionReceiver because not used in any rule.", 4); + ActivityDetectionReceiver.stopActivityDetectionReceiver(); + } + } + + if(Rule.isAnyRuleUsing(Trigger.Trigger_Enum.bluetoothConnection)) + { + if(!BluetoothReceiver.isBluetoothReceiverActive()) + { + Miscellaneous.logEvent("i", "LocationProvider", "Starting BluetoothReceiver because used in a new/changed rule.", 4); + if(BluetoothReceiver.haveAllPermission()) + BluetoothReceiver.startBluetoothReceiver(); + } + } + else + { + if(BluetoothReceiver.isBluetoothReceiverActive()) + { + Miscellaneous.logEvent("i", "LocationProvider", "Shutting down BluetoothReceiver because not used in any rule.", 4); + BluetoothReceiver.stopBluetoothReceiver(); + } + } + + if(Rule.isAnyRuleUsing(Trigger.Trigger_Enum.headsetPlugged)) + { + if(!HeadphoneJackListener.isHeadphoneJackListenerActive()) + { + Miscellaneous.logEvent("i", "LocationProvider", "Starting HeadphoneJackListener because used in a new/changed rule.", 4); + if(HeadphoneJackListener.getInstance().haveAllPermission()) + HeadphoneJackListener.getInstance().startListener(AutomationService.getInstance()); + } + } + else + { + if(HeadphoneJackListener.isHeadphoneJackListenerActive()) + { + Miscellaneous.logEvent("i", "LocationProvider", "Shutting down HeadphoneJackListener because not used in any rule.", 4); + HeadphoneJackListener.getInstance().stopListener(AutomationService.getInstance()); + } + } + + AutomationService.updateNotification(); + } +} diff --git a/app/src/main/java/com/jens/automation2/Rule.java b/app/src/main/java/com/jens/automation2/Rule.java new file mode 100644 index 0000000..e6e5801 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/Rule.java @@ -0,0 +1,1425 @@ +package com.jens.automation2; + +import android.bluetooth.BluetoothDevice; +import android.content.Context; +import android.os.AsyncTask; +import android.os.Looper; +import android.util.Log; +import android.widget.Toast; + +import com.google.android.gms.location.DetectedActivity; +import com.jens.automation2.location.WifiBroadcastReceiver; +import com.jens.automation2.receivers.ActivityDetectionReceiver; +import com.jens.automation2.receivers.BatteryReceiver; +import com.jens.automation2.receivers.BluetoothReceiver; +import com.jens.automation2.receivers.ConnectivityReceiver; +import com.jens.automation2.receivers.HeadphoneJackListener; +import com.jens.automation2.receivers.NfcReceiver; +import com.jens.automation2.receivers.NoiseListener; +import com.jens.automation2.receivers.PhoneStatusListener; +import com.jens.automation2.receivers.ProcessListener; + +import java.sql.Time; +import java.util.ArrayList; +import java.util.Calendar; +import java.util.Date; + + +public class Rule implements Comparable +{ + private static ArrayList ruleCollection = new ArrayList(); + public static boolean isAnyRuleActive = false; + + private static ArrayList ruleRunHistory = new ArrayList(); + + public static ArrayList getRuleRunHistory() + { + return ruleRunHistory; + } + + private ArrayList triggerSet; + private ArrayList actionSet; + private String name; + private boolean ruleActive = true; // rules can be deactivated, so they won't fire if you don't want them temporarily + private boolean ruleToggle = false; // rule will run again and do the opposite of its actions if applicable + + private static Date lastActivatedRuleActivationTime; + + public boolean isRuleToggle() + { + return ruleToggle; + } + public void setRuleToggle(boolean ruleToggle) + { + this.ruleToggle = ruleToggle; + } + public static ArrayList getRuleCollection() + { + return ruleCollection; + } + public boolean isRuleActive() + { + return ruleActive; + } + public void setRuleActive(boolean ruleActive) + { + this.ruleActive = ruleActive; + } + public static void setRuleCollection(ArrayList ruleCollection) + { + Rule.ruleCollection = ruleCollection; + } + public static Date getLastActivatedRuleActivationTime() + { + return lastActivatedRuleActivationTime; + } + public static Rule getLastActivatedRule() + { + if(ruleRunHistory.size() > 0) + return ruleRunHistory.get(0); + else + return null; + } + public ArrayList getTriggerSet() + { + return triggerSet; + } + public void setTriggerSet(ArrayList triggerSet) + { + this.triggerSet = triggerSet; + } + public ArrayList getActionSet() + { + return actionSet; + } + public void setActionSet(ArrayList actionSet) + { + this.actionSet = actionSet; + } + public String getName() + { + return name; + } + public void setName(String name) + { + this.name = name; + } + + public static void readFromFile() + { + ruleCollection = XmlFileInterface.ruleCollection; + } + @Override + public String toString() + { + return this.getName(); + } + public String toStringLong() + { + String returnString = ""; + + if(isRuleActive()) + returnString += "Active: "; + else + returnString += "Inactive: "; + + returnString += this.getName() + ": If "; + + for(int i=0; i= 0 + && + Miscellaneous.compareTimes(nowTime, oneTrigger.getTimeFrame().getTriggerTimeStop()) > 0 + ) + | + // Other case, start time higher than end time, timeframe goes over midnight + ( + Miscellaneous.compareTimes(oneTrigger.getTimeFrame().getTriggerTimeStart(), oneTrigger.getTimeFrame().getTriggerTimeStop()) < 0 + && + (Miscellaneous.compareTimes(oneTrigger.getTimeFrame().getTriggerTimeStart(), nowTime) >= 0 + | + Miscellaneous.compareTimes(nowTime, oneTrigger.getTimeFrame().getTriggerTimeStop()) > 0) + ) + + ) + { + // We are in the timeframe + Miscellaneous.logEvent("i", "TimeFrame", "We're currently (" + calNow.getTime().toString() + ") in the specified TimeFrame (" + oneTrigger.getTimeFrame().toString() + "). Trigger of Rule " + this.getName() + " applies.", 3); + if(oneTrigger.getTriggerParameter()) + { + Miscellaneous.logEvent("i", "TimeFrame", "That's what's specified. Trigger of Rule " + this.getName() + " applies.", 3); + //return true; + } + else + { + Miscellaneous.logEvent("i", "TimeFrame", "That's not what's specified. Trigger of Rule " + this.getName() + " doesn't apply.", 3); + return false; + } + } + else + { + Miscellaneous.logEvent("i", "TimeFrame", "We're currently (" + calNow.getTime().toString() + ", Day: " + String.valueOf(calNow.get(Calendar.DAY_OF_WEEK)) + ") not in the specified TimeFrame (" + oneTrigger.getTimeFrame().toString() + ") because of the time. Trigger of Rule " + this.getName() + " doesn\'t apply..", 5); + if(!oneTrigger.getTriggerParameter()) + { + Miscellaneous.logEvent("i", "TimeFrame", "That's what's specified. Trigger of Rule " + this.getName() + " applies.", 5); + //return true; + } + else + { + Miscellaneous.logEvent("i", "TimeFrame", "That's not what's specified. Trigger of Rule " + this.getName() + " doesn't apply.", 5); + return false; + } + // return false; + } + } + else + { + Miscellaneous.logEvent("i", "TimeFrame", "We're currently (" + calNow.getTime().toString() + ", Day: " + String.valueOf(calNow.get(Calendar.DAY_OF_WEEK)) + ") not in the specified TimeFrame (" + oneTrigger.getTimeFrame().toString() + ") because of the day. Trigger of Rule " + this.getName() + " doesn\'t apply.", 5); + return false; + } + } + else if(oneTrigger.getTriggerType().equals(Trigger.Trigger_Enum.charging)) + { + if(BatteryReceiver.isDeviceCharging(context) == 0) + { + return false; // unknown charging state, can't activate rule under these conditions + } + else if(BatteryReceiver.isDeviceCharging(context) == 1) + { + if(oneTrigger.getTriggerParameter()) //rule says when charging, but we're currently discharging + return false; + } + else if(BatteryReceiver.isDeviceCharging(context) == 2) + { + if(!oneTrigger.getTriggerParameter()) //rule says when discharging, but we're currently charging + return false; + } + } + else if(oneTrigger.getTriggerType().equals(Trigger.Trigger_Enum.usb_host_connection)) + { + if(BatteryReceiver.isUsbHostConnected() != oneTrigger.getTriggerParameter()) + { + return false; + } + } + else if(oneTrigger.getTriggerType().equals(Trigger.Trigger_Enum.batteryLevel)) + { + if(oneTrigger.getTriggerParameter()) + { + if(BatteryReceiver.getBatteryLevel() < oneTrigger.getBatteryLevel()) + { + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), context.getResources().getString(R.string.ruleDoesntApplyBatteryLowerThan) + " " + String.valueOf(oneTrigger.getBatteryLevel()), 3); + return false; + } + } + else + { + if(BatteryReceiver.getBatteryLevel() > oneTrigger.getBatteryLevel()) + { + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), context.getResources().getString(R.string.ruleDoesntApplyBatteryHigherThan) + " " + String.valueOf(oneTrigger.getBatteryLevel()), 3); + return false; + } + } + } + else if(oneTrigger.getTriggerType().equals(Trigger.Trigger_Enum.speed)) + { + if(oneTrigger.getTriggerParameter()) + { + if(com.jens.automation2.location.LocationProvider.getSpeed() < oneTrigger.getSpeed()) + { + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), context.getResources().getString(R.string.ruleDoesntApplyWeAreSlowerThan) + " " + String.valueOf(oneTrigger.getSpeed()), 3); + return false; + } + } + else + { + if(com.jens.automation2.location.LocationProvider.getSpeed() > oneTrigger.getSpeed()) + { + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), context.getResources().getString(R.string.ruleDoesntApplyWeAreFasterThan) + " " + String.valueOf(oneTrigger.getSpeed()), 3); + return false; + } + } + } + else if(oneTrigger.getTriggerType().equals(Trigger.Trigger_Enum.noiseLevel)) + { + if(oneTrigger.getTriggerParameter()) + { + if(NoiseListener.getNoiseLevelDb() < oneTrigger.getNoiseLevelDb()) + { + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), context.getResources().getString(R.string.ruleDoesntApplyItsQuieterThan) + " " + String.valueOf(oneTrigger.getNoiseLevelDb()), 3); + return false; + } + } + else + { + if(NoiseListener.getNoiseLevelDb() > oneTrigger.getNoiseLevelDb()) + { + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), context.getResources().getString(R.string.ruleDoesntApplyItsLouderThan) + " " + String.valueOf(oneTrigger.getNoiseLevelDb()), 3); + return false; + } + } + } + else if(oneTrigger.getTriggerType().equals(Trigger.Trigger_Enum.wifiConnection)) + { + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), "Checking for wifi state", 4); + if(oneTrigger.getTriggerParameter() == WifiBroadcastReceiver.lastConnectedState) // connected / disconnected + { + if(oneTrigger.getWifiName().length() > 0) // only check if any wifi name specified, otherwise any wifi will do + { + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), "Wifi name specified, checking that.", 4); + if(!WifiBroadcastReceiver.getLastWifiSsid().equals(oneTrigger.getWifiName())) + { + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), String.format(context.getResources().getString(R.string.ruleDoesntApplyNotTheCorrectSsid), oneTrigger.getWifiName(), WifiBroadcastReceiver.getLastWifiSsid()), 3); + return false; + } + else + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), "Wifi name matches. Rule will apply.", 4); + } + else + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), "No wifi name specified, any will do.", 4); + } + else + { + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), "Wifi state not correct, demanded " + String.valueOf(oneTrigger.getTriggerParameter() + ", got " + String.valueOf(WifiBroadcastReceiver.lastConnectedState)), 4); + return false; + } + } + else if(oneTrigger.getTriggerType().equals(Trigger.Trigger_Enum.process_started_stopped)) + { + boolean running = ProcessListener.getRunningApps().contains(oneTrigger.getProcessName()); + + if(running) + Miscellaneous.logEvent("i", "ProcessMonitoring", "App " + oneTrigger.getProcessName() + " is currently running.", 4); + else + Miscellaneous.logEvent("i", "ProcessMonitoring", "App " + oneTrigger.getProcessName() + " is not running.", 4); + + if(running != oneTrigger.getTriggerParameter()) + { + Miscellaneous.logEvent("i", "ProcessMonitoring", "Trigger doesn't apply.", 4); + return false; + } + + Miscellaneous.logEvent("i", "ProcessMonitoring", "Trigger applies.", 4); + } + else if(oneTrigger.getTriggerType().equals(Trigger.Trigger_Enum.airplaneMode)) + { + if(ConnectivityReceiver.isAirplaneMode(context) != oneTrigger.getTriggerParameter()) + { + return false; + } + } + else if(oneTrigger.getTriggerType().equals(Trigger.Trigger_Enum.roaming)) + { + if(ConnectivityReceiver.isRoaming(context) != oneTrigger.getTriggerParameter()) + { + return false; + } + } + else if(oneTrigger.getTriggerType().equals(Trigger.Trigger_Enum.phoneCall)) + { + if(oneTrigger.getPhoneNumber().equals("any") | oneTrigger.getPhoneNumber().equals(PhoneStatusListener.getLastPhoneNumber())) + { + if(PhoneStatusListener.isInACall() == oneTrigger.getTriggerParameter()) + { + if(oneTrigger.getPhoneDirection() == 0 | (oneTrigger.getPhoneDirection() == PhoneStatusListener.getLastPhoneDirection())) + { + // Everything's allright + } + else + { + Miscellaneous.logEvent("i", "Rule", "Rule doesn't apply. Wrong direction. Demanded: " + String.valueOf(oneTrigger.getPhoneDirection()) + ", got: " + String.valueOf(PhoneStatusListener.getLastPhoneDirection()), 4); + return false; + } + } + else + { + Miscellaneous.logEvent("i", "Rule", "Rule doesn't apply. Wrong call status. Demanded: " + String.valueOf(oneTrigger.getTriggerParameter()) + ", got: " + String.valueOf(PhoneStatusListener.isInACall()), 4); + return false; + } + } + else + Miscellaneous.logEvent("i", "Rule", "Rule doesn't apply. Wrong phone number. Demanded: " + oneTrigger.getPhoneNumber() + ", got: " + PhoneStatusListener.getLastPhoneNumber(), 4); + } + else if(oneTrigger.getTriggerType().equals(Trigger.Trigger_Enum.nfcTag)) + { + if(NfcReceiver.lastReadLabel == null) + { + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), context.getResources().getString(R.string.ruleDoesntApplyNoTagLabel), 3); + return false; + } + else if(!NfcReceiver.lastReadLabel.equals(oneTrigger.getNfcTagId())) + { + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), context.getResources().getString(R.string.ruleDoesntApplyWrongTagLabel) + " " + NfcReceiver.lastReadLabel + " / " + oneTrigger.getNfcTagId(), 3); + return false; + } + } + else if(oneTrigger.getTriggerType().equals(Trigger.Trigger_Enum.activityDetection)) + { + if(ActivityDetectionReceiver.getActivityDetectionLastResult() != null) + { + boolean found = false; + for(DetectedActivity oneDetectedActivity : ActivityDetectionReceiver.getActivityDetectionLastResult().getProbableActivities()) + { + if(oneDetectedActivity.getType() == oneTrigger.getActivityDetectionType()) + found = true; + } + + if(!found) + { + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), String.format(context.getResources().getString(R.string.ruleDoesntApplyActivityNotPresent), ActivityDetectionReceiver.getDescription(oneTrigger.getActivityDetectionType())), 3); + return false; + } + else + { + for(DetectedActivity oneDetectedActivity : ActivityDetectionReceiver.getActivityDetectionLastResult().getProbableActivities()) + { + if(oneDetectedActivity.getType() == oneTrigger.getActivityDetectionType() && oneDetectedActivity.getConfidence() < Settings.activityDetectionRequiredProbability) + { + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), String.format(context.getResources().getString(R.string.ruleDoesntApplyActivityGivenButTooLowProbability), ActivityDetectionReceiver.getDescription(oneDetectedActivity.getType()), String.valueOf(oneDetectedActivity.getConfidence()), String.valueOf(Settings.activityDetectionRequiredProbability)), 3); + return false; + } + } + } + } + } + else if(oneTrigger.getTriggerType().equals(Trigger.Trigger_Enum.bluetoothConnection)) + { + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), "Checking for bluetooth...", 4); + +// if( // connected / disconnected +// (oneTrigger.getTriggerParameter() && (BluetoothReceiver.getLastAction().equals(android.bluetooth.BluetoothDevice.ACTION_ACL_CONNECTED) | BluetoothReceiver.getLastAction().equals("android.bluetooth.device.action.ACL_CONNECTED"))) +// | +// (!oneTrigger.getTriggerParameter() && (BluetoothReceiver.getLastAction().equals(android.bluetooth.BluetoothDevice.ACTION_ACL_DISCONNECT_REQUESTED) | BluetoothReceiver.getLastAction().equals(android.bluetooth.BluetoothDevice.ACTION_ACL_DISCONNECTED) | BluetoothReceiver.getLastAction().equals("android.bluetooth.device.action.ACTION_ACL_DISCONNECT_REQUESTED") | BluetoothReceiver.getLastAction().equals("android.bluetooth.device.action.ACTION_ACL_DISCONNECTED"))) +// ) +// { +// if(oneTrigger.getBluetoothDeviceAddress() != null) +// { +// if(oneTrigger.getBluetoothDeviceAddress().equals("")) +// { +// Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), "No bluetooth address specified, any will do.", 4); +// } +// else if(oneTrigger.getBluetoothDeviceAddress().equals("")) +// { +// // ??? +// } +// else +// { +// Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), "Bluetooth address specified, checking that.", 4); +// if(!BluetoothReceiver.getLastAffectedDevice().getAddress().equals(oneTrigger.getBluetoothDeviceAddress())) +// { +// Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), context.getResources().getString(R.string.ruleDoesntApplyNotTheCorrectDeviceAddress), 3); +// return false; +// } +// else +// Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), "Bluetooth address matches. Rule will apply.", 4); +// } +// } +// } +// else if(BluetoothReceiver.getLastAction().equals(android.bluetooth.BluetoothDevice.ACTION_FOUND) | BluetoothReceiver.getLastAction().equals(android.bluetooth.BluetoothDevice.ACTION_FOUND)) +// { +// if(!oneTrigger.getTriggerParameter()) +// { +// Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), context.getResources().getString(R.string.ruleDoesntApplyDeviceInRangeButShouldNotBe), 3); +// return false; +// } +// } +// else // above only checks for last action, this checks for things in the past + { + if(oneTrigger.getBluetoothDeviceAddress().equals("")) + { + if(oneTrigger.getBluetoothEvent().equals(BluetoothDevice.ACTION_ACL_CONNECTED)) + { + if(BluetoothReceiver.isAnyDeviceConnected() != oneTrigger.getTriggerParameter()) + return false; + } + else if((oneTrigger.getBluetoothEvent().equals(BluetoothDevice.ACTION_ACL_DISCONNECTED))) + { + if(BluetoothReceiver.isAnyDeviceConnected() != oneTrigger.getTriggerParameter()) + return false; + } + else + { + // range + if(BluetoothReceiver.isAnyDeviceInRange() != oneTrigger.getTriggerParameter()) + return false; + } + } + else if(oneTrigger.getBluetoothDeviceAddress().equals("")) + { + if(oneTrigger.getBluetoothEvent().equals(BluetoothDevice.ACTION_ACL_CONNECTED)) + { + if(BluetoothReceiver.isAnyDeviceConnected() == oneTrigger.getTriggerParameter()) + return false; + } + else if((oneTrigger.getBluetoothEvent().equals(BluetoothDevice.ACTION_ACL_DISCONNECTED))) + { + if(BluetoothReceiver.isAnyDeviceConnected() == oneTrigger.getTriggerParameter()) + return false; + } + else + { + // range + if(BluetoothReceiver.isAnyDeviceInRange() == oneTrigger.getTriggerParameter()) + return false; + } + } + else if(oneTrigger.getBluetoothDeviceAddress().length() > 0) + { + if(oneTrigger.getBluetoothEvent().equals(BluetoothDevice.ACTION_ACL_CONNECTED)) + { + if(BluetoothReceiver.isDeviceCurrentlyConnected(BluetoothReceiver.getDeviceByAddress(oneTrigger.getBluetoothDeviceAddress())) != oneTrigger.getTriggerParameter()) + return false; + } + else if((oneTrigger.getBluetoothEvent().equals(BluetoothDevice.ACTION_ACL_DISCONNECTED))) + { + if(BluetoothReceiver.isDeviceCurrentlyConnected(BluetoothReceiver.getDeviceByAddress(oneTrigger.getBluetoothDeviceAddress())) != oneTrigger.getTriggerParameter()) + return false; + } + else + { + // range + if(BluetoothReceiver.isDeviceInRange(BluetoothReceiver.getDeviceByAddress(oneTrigger.getBluetoothDeviceAddress())) != oneTrigger.getTriggerParameter()) + return false; + } + } + else + { + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), context.getResources().getString(R.string.ruleDoesntApplyStateNotCorrect), 3); + return false; + } + } + } + else if(oneTrigger.getTriggerType().equals(Trigger.Trigger_Enum.headsetPlugged)) + { + if(HeadphoneJackListener.isHeadsetConnected() != oneTrigger.getTriggerParameter()) + return false; + else + if(oneTrigger.getHeadphoneType() != 2 && oneTrigger.getHeadphoneType() != HeadphoneJackListener.getHeadphoneType()) + { + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), context.getResources().getString(R.string.ruleDoesntApplyWrongHeadphoneType), 3); + return false; + } + } + } + + return true; + } + + Miscellaneous.logEvent("i", String.format(context.getResources().getString(R.string.ruleCheckOf), this.getName()), String.format(context.getResources().getString(R.string.ruleIsDeactivatedCantApply), this.getName()), 3); + return false; + } + + private class ActivateRuleTask extends AsyncTask + { + @Override + protected Void doInBackground(Object... params) + { +// Miscellaneous.logEvent("i", "Rule", ((Context) params[0]).getResources().getString(R.string.usingNewThreadForRuleExecution), 5); + + Thread.setDefaultUncaughtExceptionHandler(Miscellaneous.uncaughtExceptionHandler); + + // without this line debugger will - for some reason - skip all breakpoints in this class + if(android.os.Debug.isDebuggerConnected()) + android.os.Debug.waitForDebugger(); + + if (Looper.myLooper() == null) + Looper.prepare(); + + activateInternally((AutomationService)params[0], (Boolean)params[1]); + + return null; + } + + @Override + protected void onProgressUpdate(String... messages) + { + AutomationService service = AutomationService.getInstance(); + service.speak(messages[0], false); + Toast.makeText(service, messages[0], Toast.LENGTH_LONG).show(); + + super.onProgressUpdate(messages); + } + + @Override + protected void onPostExecute(Void result) + { + AutomationService.updateNotification(); + ActivityMainScreen.updateMainScreen(); + super.onPostExecute(result); + } + + /** + * Will activate the rule. Should be called by a separate execution thread + * @param automationService + */ + protected void activateInternally(AutomationService automationService, boolean force) + { + boolean isActuallyToggable = isActuallyToggable(); + + boolean notLastActive = getLastActivatedRule() == null || !getLastActivatedRule().equals(Rule.this); + boolean doToggle = ruleToggle && isActuallyToggable; + + if(notLastActive | force | doToggle) + { + String message; + if(!doToggle) + message = String.format(automationService.getResources().getString(R.string.ruleActivate), Rule.this.getName()); + else + message = String.format(automationService.getResources().getString(R.string.ruleActivateToggle), Rule.this.getName()); + Miscellaneous.logEvent("i", "Rule", message, 2); +// automationService.speak(message); +// Toast.makeText(automationService, message, Toast.LENGTH_LONG).show(); + if(Settings.startNewThreadForRuleActivation) + publishProgress(message); + + for(int i = 0; i< Rule.this.getActionSet().size(); i++) + Rule.this.getActionSet().get(i).run(automationService, doToggle); + + // Keep log of last x rule activations (Settings) + try + { + Rule.ruleRunHistory.add(0, Rule.this); // add at beginning for better visualization + Rule.lastActivatedRuleActivationTime = new Date(); + while(ruleRunHistory.size() > Settings.rulesThatHaveBeenRanHistorySize) + ruleRunHistory.remove(ruleRunHistory.size()-1); + String history = ""; + for(Rule rule : ruleRunHistory) + history += rule.getName() + ", "; + if(history.length() > 0) + history = history.substring(0, history.length()-2); + Miscellaneous.logEvent("i", "Rule history", "Most recent first: " + history, 4); + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "Rule history error", Log.getStackTraceString(e), 3); + } + + Miscellaneous.logEvent("i", "Rule", String.format(Miscellaneous.getAnyContext().getResources().getString(R.string.ruleActivationComplete), Rule.this.getName()), 2); + } + else + { + Miscellaneous.logEvent("i", "Rule", "Request to activate rule " + Rule.this.getName() + ", but it is the last one that was activated. Won't do it again.", 3); + } + } + } + + public void activate(AutomationService automationService, boolean force) + { + ActivateRuleTask task = new ActivateRuleTask(); + +// if(Settings.startNewThreadForRuleActivation) + task.execute(automationService, force); +// else +// { +// task.activateInternally(automationService, force); +// AutomationService.updateNotification(); +// ActivityMainScreen.updateMainScreen(); +// } + } + + public static ArrayList findRuleCandidatesByPoi(PointOfInterest searchPoi, boolean triggerParameter) + { + Miscellaneous.logEvent("i", "RuleSearch", "Searching for rules referencing POI " + searchPoi.getName() + ". Total size of ruleset: " + String.valueOf(ruleCollection.size()), 4); + + ArrayList ruleCandidates = new ArrayList(); + + for(int i=0; i findRuleCandidatesByTimeFrame(TimeFrame searchTimeFrame, boolean triggerParameter) + { + ArrayList ruleCandidates = new ArrayList(); + + for(int i=0; i findRuleCandidatesByTime(Time searchTime) + { + Miscellaneous.logEvent("i", "RuleSearch", "Searching for rules with TimeFrame with time " + searchTime.toString() + ". RuleCollection-Size: " + String.valueOf(ruleCollection.size()), 3);; + ArrayList ruleCandidates = new ArrayList(); + + for(Rule oneRule : ruleCollection) + { + innerloop: + for(Trigger oneTrigger : oneRule.getTriggerSet()) + { + if(oneTrigger.getTriggerType() == Trigger.Trigger_Enum.timeFrame) + { + Miscellaneous.logEvent("i", "RuleSearch", "Searching interval: " + oneTrigger.getTimeFrame().getTriggerTimeStart().toString() + " to " + oneTrigger.getTimeFrame().getTriggerTimeStop().toString(), 5); + Miscellaneous.logEvent("i", "RuleSearch", "interval start: " + String.valueOf(oneTrigger.getTimeFrame().getTriggerTimeStart().getTime()), 5); + Miscellaneous.logEvent("i", "RuleSearch", "search time: " + String.valueOf(searchTime.getTime()), 5); + Miscellaneous.logEvent("i", "RuleSearch", "interval stop: " + String.valueOf(oneTrigger.getTimeFrame().getTriggerTimeStop().getTime()), 5); + + if(oneTrigger.getTimeFrame().getTriggerTimeStart().getTime() > oneTrigger.getTimeFrame().getTriggerTimeStop().getTime()) + { + Miscellaneous.logEvent("i", "Timeframe search", "Rule goes over midnight.", 5); + if(oneTrigger.getTimeFrame().getTriggerTimeStart().getTime() <= searchTime.getTime() | searchTime.getTime() <= oneTrigger.getTimeFrame().getTriggerTimeStop().getTime()+20000) //add 20 seconds because of delay + { + ruleCandidates.add(oneRule); + break innerloop; //if the poi is found we don't need to search the other triggers in the same rule + } + } + else if(oneTrigger.getTimeFrame().getTriggerTimeStart().getTime() <= searchTime.getTime() && searchTime.getTime() <= oneTrigger.getTimeFrame().getTriggerTimeStop().getTime()+20000) //add 20 seconds because of delay + { + Miscellaneous.logEvent("i", "RuleSearch", "Rule found with TimeFrame with time " + searchTime.toString(), 3); + ruleCandidates.add(oneRule); + break innerloop; //if the poi is found we don't need to search the other triggers in the same rule + } + } + } + } + + Miscellaneous.logEvent("i", "RuleSearch", String.valueOf(ruleCandidates.size()) + " Rule(s) found with TimeFrame with time " + searchTime.toString(), 3); + + return ruleCandidates; + } + + public static ArrayList findRuleCandidatesByTimeFrame() + { + ArrayList ruleCandidates = new ArrayList(); + + for(Rule oneRule : ruleCollection) + { + innerloop: + for(Trigger oneTrigger : oneRule.getTriggerSet()) + { + if(oneTrigger.getTriggerType() == Trigger.Trigger_Enum.timeFrame) + { + ruleCandidates.add(oneRule); + break innerloop; //if the poi is found we don't need to search the other triggers in the same rule + } + } + } + + return ruleCandidates; + } + + public static ArrayList findRuleCandidatesByCharging(boolean triggerParameter) + { + ArrayList ruleCandidates = new ArrayList(); + + for(Rule oneRule : ruleCollection) + { + innerloop: + for(Trigger oneTrigger : oneRule.getTriggerSet()) + { + if(oneTrigger.getTriggerType() == Trigger.Trigger_Enum.charging) + { + if(oneTrigger.getTriggerParameter() == triggerParameter) + { + ruleCandidates.add(oneRule); + break innerloop; //if the poi is found we don't need to search the other triggers in the same rule + } + } + } + } + + return ruleCandidates; + } + + public static ArrayList findRuleCandidatesByUsbHost(boolean triggerParameter) + { + ArrayList ruleCandidates = new ArrayList(); + + for(Rule oneRule : ruleCollection) + { + innerloop: + for(Trigger oneTrigger : oneRule.getTriggerSet()) + { + if(oneTrigger.getTriggerType() == Trigger.Trigger_Enum.usb_host_connection) + { + if(oneTrigger.getTriggerParameter() == triggerParameter) + { + ruleCandidates.add(oneRule); + break innerloop; //if the poi is found we don't need to search the other triggers in the same rule + } + } + } + } + + return ruleCandidates; + } + + public static ArrayList findRuleCandidatesByBatteryLevel() + { + ArrayList ruleCandidates = new ArrayList(); + + for(Rule oneRule : ruleCollection) + { + innerloop: + for(Trigger oneTrigger : oneRule.getTriggerSet()) + { + if(oneTrigger.getTriggerType() == Trigger.Trigger_Enum.batteryLevel) + { +// if(oneTrigger.getTriggerParameter() == triggerParameter) +// { + ruleCandidates.add(oneRule); + break innerloop; //if the poi is found we don't need to search the other triggers in the same rule +// } + } + } + } + + return ruleCandidates; + } + + public static ArrayList findRuleCandidatesBySpeed() + { + ArrayList ruleCandidates = new ArrayList(); + + for(Rule oneRule : ruleCollection) + { + innerloop: + for(Trigger oneTrigger : oneRule.getTriggerSet()) + { + if(oneTrigger.getTriggerType() == Trigger.Trigger_Enum.speed) + { +// if(oneTrigger.getTriggerParameter() == triggerParameter) +// { + ruleCandidates.add(oneRule); + break innerloop; //if the poi is found we don't need to search the other triggers in the same rule +// } + } + } + } + + return ruleCandidates; + } + + public static ArrayList findRuleCandidatesByNoiseLevel() + { + ArrayList ruleCandidates = new ArrayList(); + + for(Rule oneRule : ruleCollection) + { + innerloop: + for(Trigger oneTrigger : oneRule.getTriggerSet()) + { + if(oneTrigger.getTriggerType() == Trigger.Trigger_Enum.noiseLevel) + { +// if(oneTrigger.getTriggerParameter() == triggerParameter) +// { + ruleCandidates.add(oneRule); + break innerloop; //if the poi is found we don't need to search the other triggers in the same rule +// } + } + } + } + + return ruleCandidates; + } + + public static ArrayList findRuleCandidatesByWifiConnection() + { + ArrayList ruleCandidates = new ArrayList(); + + for(Rule oneRule : ruleCollection) + { + innerloop: + for(Trigger oneTrigger : oneRule.getTriggerSet()) + { + if(oneTrigger.getTriggerType() == Trigger.Trigger_Enum.wifiConnection) + { +// if(oneTrigger.getTriggerParameter() == triggerParameter) +// { + ruleCandidates.add(oneRule); + break innerloop; //we don't need to search the other triggers in the same rule +// } + } + } + } + + return ruleCandidates; + } + + public static ArrayList findRuleCandidatesByBluetoothConnection() + { + ArrayList ruleCandidates = new ArrayList(); + + for(Rule oneRule : ruleCollection) + { + innerloop: + for(Trigger oneTrigger : oneRule.getTriggerSet()) + { + if(oneTrigger.getTriggerType() == Trigger.Trigger_Enum.bluetoothConnection) + { +// if(oneTrigger.getTriggerParameter() == triggerParameter) +// { + ruleCandidates.add(oneRule); + break innerloop; //we don't need to search the other triggers in the same rule +// } + } + } + } + + return ruleCandidates; + } + + public static ArrayList findRuleCandidatesByProcess() + { + ArrayList ruleCandidates = new ArrayList(); + + for(Rule oneRule : ruleCollection) + { + innerloop: + for(Trigger oneTrigger : oneRule.getTriggerSet()) + { + if(oneTrigger.getTriggerType() == Trigger.Trigger_Enum.process_started_stopped) + { +// if(oneTrigger.getTriggerParameter() == triggerParameter) +// { + ruleCandidates.add(oneRule); + break innerloop; //we don't need to search the other triggers in the same rule +// } + } + } + } + + return ruleCandidates; + } + + public static ArrayList findRuleCandidatesByAirplaneMode(boolean triggerParameter) + { + ArrayList ruleCandidates = new ArrayList(); + + for(Rule oneRule : ruleCollection) + { + innerloop: + for(Trigger oneTrigger : oneRule.getTriggerSet()) + { + if(oneTrigger.getTriggerType() == Trigger.Trigger_Enum.airplaneMode) + { + if(oneTrigger.getTriggerParameter() == triggerParameter) + { + ruleCandidates.add(oneRule); + break innerloop; //we don't need to search the other triggers in the same rule + } + } + } + } + + return ruleCandidates; + } + + public static ArrayList findRuleCandidatesByRoaming(boolean triggerParameter) + { + ArrayList ruleCandidates = new ArrayList(); + + for(Rule oneRule : ruleCollection) + { + innerloop: + for(Trigger oneTrigger : oneRule.getTriggerSet()) + { + if(oneTrigger.getTriggerType() == Trigger.Trigger_Enum.roaming) + { + if(oneTrigger.getTriggerParameter() == triggerParameter) + { + ruleCandidates.add(oneRule); + break innerloop; //we don't need to search the other triggers in the same rule + } + } + } + } + + return ruleCandidates; + } + + public static ArrayList findRuleCandidatesByPhoneCall(boolean triggerParameter) + { + ArrayList ruleCandidates = new ArrayList(); + + for(Rule oneRule : ruleCollection) + { + innerloop: + for(Trigger oneTrigger : oneRule.getTriggerSet()) + { + if(oneTrigger.getTriggerType() == Trigger.Trigger_Enum.phoneCall) + { + if(oneTrigger.getTriggerParameter() == triggerParameter) + { + ruleCandidates.add(oneRule); + break innerloop; //we don't need to search the other triggers in the same rule + } + } + } + } + + return ruleCandidates; + } + + public static ArrayList findRuleCandidatesByNfc() + { + ArrayList ruleCandidates = new ArrayList(); + + for(Rule oneRule : ruleCollection) + { + innerloop: + for(Trigger oneTrigger : oneRule.getTriggerSet()) + { + if(oneTrigger.getTriggerType() == Trigger.Trigger_Enum.nfcTag) + { +// if(oneTrigger.getTriggerParameter() == triggerParameter) +// { + ruleCandidates.add(oneRule); + break innerloop; //we don't need to search the other triggers in the same rule +// } + } + } + } + + return ruleCandidates; + } + + public static ArrayList findRuleCandidatesByActivityDetection() + { + ArrayList ruleCandidates = new ArrayList(); + + for(Rule oneRule : ruleCollection) + { + innerloop: + for(Trigger oneTrigger : oneRule.getTriggerSet()) + { + if(oneTrigger.getTriggerType() == Trigger.Trigger_Enum.activityDetection) + { +// if(oneTrigger.getTriggerParameter() == triggerParameter) +// { + ruleCandidates.add(oneRule); + break innerloop; //we don't need to search the other triggers in the same rule +// } + } + } + } + + return ruleCandidates; + } + + public static ArrayList findRuleCandidatesByPoi(PointOfInterest searchPoi) + { + ArrayList ruleCandidates = new ArrayList(); + + for(Rule oneRule : ruleCollection) + { + innerloop: + for(Trigger oneTrigger : oneRule.getTriggerSet()) + { + if(oneTrigger.getTriggerType() == Trigger.Trigger_Enum.pointOfInterest) + { + if(oneTrigger.getPointOfInterest() != null && oneTrigger.getPointOfInterest().equals(searchPoi)) // != null to exclude those who are referring all locations ("entering any location") + { + ruleCandidates.add(oneRule); + break innerloop; //if the poi is found we don't need to search the other triggers in the same rule + } + } + } + } + + return ruleCandidates; + } + + public static ArrayList findRuleCandidatesByHeadphoneJack(boolean triggerParameter) + { + ArrayList ruleCandidates = new ArrayList(); + + for(Rule oneRule : ruleCollection) + { + innerloop: + for(Trigger oneTrigger : oneRule.getTriggerSet()) + { + if(oneTrigger.getTriggerType() == Trigger.Trigger_Enum.headsetPlugged) + { + if(oneTrigger.getTriggerParameter() == triggerParameter) + { + ruleCandidates.add(oneRule); + break innerloop; //we don't need to search the other triggers in the same rule + } + } + } + } + + return ruleCandidates; + } + + public static ArrayList findRuleCandidatesByProfile(Profile profile) + { + ArrayList ruleCandidates = new ArrayList(); + + for(Rule oneRule : ruleCollection) + { + innerloop: + for(Action oneAction : oneRule.getActionSet()) + { + if(oneAction.getAction() == Action.Action_Enum.changeSoundProfile) + { + if(oneAction.getParameter2().equals(profile.getOldName())) // != null to exclude those who are referring all locations ("entering any location") + { + ruleCandidates.add(oneRule); + break innerloop; //if the profile is found we don't need to search the other triggers in the same rule + } + } + } + } + + return ruleCandidates; + } + + public static boolean isAnyRuleUsing(Trigger.Trigger_Enum triggerType) + { + for(Rule rule: ruleCollection) + { + if(rule.isRuleActive()) + { + for(Trigger trigger : rule.getTriggerSet()) + { + if(trigger.getTriggerType().equals(triggerType)) + { + Miscellaneous.logEvent("i", "Rule->isAnyRuleUsing()", String.format(Miscellaneous.getAnyContext().getString(R.string.atLeastRuleXisUsingY), rule.getName(), triggerType.getFullName(Miscellaneous.getAnyContext())), 5); + return true; + } + } + } + } + + return false; + } + + public static boolean isAnyRuleUsing(Action.Action_Enum actionType) + { + for(Rule rule: ruleCollection) + { + if(rule.isRuleActive()) + { + for(Action action : rule.getActionSet()) + { + if(action.getAction().equals(actionType)) + { + Miscellaneous.logEvent("i", "Rule->isAnyRuleUsing()", String.format(Miscellaneous.getAnyContext().getString(R.string.atLeastRuleXisUsingY), rule.getName(), actionType.getFullName(Miscellaneous.getAnyContext())), 5); + return true; + } + } + } + } + + return false; + } + + @Override + public int compareTo(Rule another) + { + return this.getName().compareTo(another.getName()); + } + + public boolean haveEnoughPermissions() + { + return ActivityPermissions.havePermissionsForRule(this, Miscellaneous.getAnyContext()); + } +} diff --git a/app/src/main/java/com/jens/automation2/Settings.java b/app/src/main/java/com/jens/automation2/Settings.java new file mode 100644 index 0000000..3c2ff8e --- /dev/null +++ b/app/src/main/java/com/jens/automation2/Settings.java @@ -0,0 +1,503 @@ +package com.jens.automation2; + +import android.content.Context; +import android.content.SharedPreferences; +import android.preference.PreferenceManager; +import android.util.Log; + +import java.util.Map; +import java.util.Set; + +public class Settings implements SharedPreferences +{ + public static final int rulesThatHaveBeenRanHistorySize = 10; + public static final String folderName = "Automation"; + + public static long minimumDistanceChangeForGpsUpdate; + public static long minimumDistanceChangeForNetworkUpdate; + public static long satisfactoryAccuracyGps; + public static long satisfactoryAccuracyNetwork; + public static int gpsTimeout; + public static long minimumTimeBetweenUpdate; + public static boolean startServiceAtSystemBoot; + public static boolean writeLogFile; + public static long logLevel; + public static int logFileMaxSize; + public static boolean useTextToSpeechOnNormal; + public static boolean useTextToSpeechOnVibrate; + public static boolean useTextToSpeechOnSilent; + public static boolean muteTextToSpeechDuringCalls; + public static int positioningEngine; + public static boolean useWifiForPositioning; + public static boolean useAccelerometerForPositioning; + public static long useAccelerometerAfterIdleTime; + public static long accelerometerMovementThreshold; + public static long speedMaximumTimeBetweenLocations; + public static long timeBetweenNoiseLevelMeasurements; + public static long lengthOfNoiseLevelMeasurements; + public static long referenceValueForNoiseLevelMeasurements; + public static boolean hasServiceBeenRunning; + public static boolean startServiceAfterAppUpdate; + public static boolean startNewThreadForRuleActivation; + public static boolean showIconWhenServiceIsRunning; + public static boolean httpAcceptAllCertificates; + public static int httpAttempts; + public static int httpAttemptsTimeout; + public static int httpAttemptGap; + public static PointOfInterest lastActivePoi; + public static boolean rememberLastActivePoi; + public static int locationRingBufferSize; + public static long timeBetweenProcessMonitorings; + public static int activityDetectionFrequency; + public static int activityDetectionRequiredProbability; + public static boolean privacyLocationing; + public static int startScreen; + public static boolean executeRulesAndProfilesWithSingleClick; + public static boolean lockSoundChanges; + public static boolean noticeAndroid9MicrophoneShown; + public static boolean noticeAndroid10WifiShown; + + /* + Generic settings valid for all installations and not changable + */ + public static final String dateFormat = "E dd.MM.yyyy HH:mm:ss:ssss"; + + protected static final int default_positioningEngine = 0; + protected static final long default_minimumDistanceChangeForGpsUpdate = 100; + protected static final long default_minimumDistanceChangeForNetworkUpdate = 500; // in Meters + protected static final long default_satisfactoryAccuracyGps = 50; + protected static final long default_satisfactoryAccuracyNetwork = 1000; + protected static final int default_gpsTimeout = 300; // seconds + protected static final long default_minimumTimeBetweenUpdate = 30000; // in Milliseconds + protected static final boolean default_startServiceAtSystemBoot = false; + protected static final boolean default_writeLogFile = false; + protected static final long default_logLevel = 2; + protected static final int default_logFileMaxSize = 10; + protected static final boolean default_useTextToSpeechOnNormal = false; + protected static final boolean default_useTextToSpeechOnVibrate = false; + protected static final boolean default_useTextToSpeechOnSilent = false; + protected static final boolean default_muteTextToSpeechDuringCalls = true; + protected static final boolean default_useWifiForPositioning = true; + protected static final boolean default_useAccelerometerForPositioning = true; + protected static final long default_useAccelerometerAfterIdleTime = 5; + protected static final long default_accelerometerMovementThreshold = 2; + protected static final long default_speedMaximumTimeBetweenLocations = 4; + protected static final long default_timeBetweenNoiseLevelMeasurements = 60; + protected static final long default_lengthOfNoiseLevelMeasurements = 5; + protected static final long default_referenceValueForNoiseLevelMeasurements = 20; + protected static final boolean default_hasServiceBeenRunning = false; + protected static final boolean default_startServiceAfterAppUpdate = true; + protected static final boolean default_startNewThreadForRuleActivation = true; + protected static final boolean default_showIconWhenServiceIsRunning = true; + protected static final boolean default_httpAcceptAllCertificates = false; + protected static final int default_httpAttempts = 3; + protected static final int default_httpAttemptsTimeout = 60; + protected static final int default_httpAttemptGap = 2; + protected static final PointOfInterest default_lastActivePoi = null; + protected static final boolean default_rememberLastActivePoi = true; + protected static final int default_locationRingBufferSize=3; + protected static final long default_timeBetweenProcessMonitorings = 60; + protected static final int default_activityDetectionFrequency = 60; + protected static final int default_activityDetectionRequiredProbability = 75; + protected static final boolean default_privacyLocationing = false; + protected static final int default_startScreen = 0; + protected static final boolean default_executeRulesAndProfilesWithSingleClick = false; + protected static final boolean default_lockSoundChanges = false; + public final static int lockSoundChangesInterval = 15; + + @Override + public boolean contains(String arg0) + { + return false; + } + @Override + public Editor edit() + { + // TODO Auto-generated method stub + return null; + } + @Override + public Map getAll() + { + // TODO Auto-generated method stub + return null; + } + @Override + public boolean getBoolean(String arg0, boolean arg1) + { + // TODO Auto-generated method stub + return false; + } + @Override + public float getFloat(String arg0, float arg1) + { + // TODO Auto-generated method stub + return 0; + } + @Override + public int getInt(String arg0, int arg1) + { + // TODO Auto-generated method stub + return 0; + } + @Override + public long getLong(String arg0, long arg1) + { + // TODO Auto-generated method stub + return 0; + } + @Override + public String getString(String arg0, String arg1) + { + // TODO Auto-generated method stub + return null; + } + @Override + public void registerOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener arg0) + { + // TODO Auto-generated method stub + + } + @Override + public void unregisterOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener arg0) + { + // TODO Auto-generated method stub + + } + + public static void readFromPersistentStorage(Context context) + { + try + { + Miscellaneous.logEvent("i", context.getResources().getString(R.string.settings), context.getResources().getString(R.string.refreshingSettingsFromFileToMemory), 4); + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context); + + startServiceAtSystemBoot = prefs.getBoolean("startServiceAtSystemBoot", default_startServiceAtSystemBoot); + writeLogFile = prefs.getBoolean("writeLogFile", default_writeLogFile); + + boolean useTextToSpeech = false; + if(prefs.contains("useTextToSpeech")) + { + useTextToSpeech = prefs.getBoolean("useTextToSpeech", false); + } + if(prefs.contains("useTextToSpeech") && !useTextToSpeech) // until all old users have been upgraded + { + useTextToSpeechOnNormal = false; + useTextToSpeechOnVibrate = false; + useTextToSpeechOnSilent = false; + } + else + { + useTextToSpeechOnNormal = prefs.getBoolean("useTextToSpeechOnNormal", default_useTextToSpeechOnNormal); + useTextToSpeechOnVibrate = prefs.getBoolean("useTextToSpeechOnVibrate", default_useTextToSpeechOnVibrate); + useTextToSpeechOnSilent = prefs.getBoolean("useTextToSpeechOnSilent", default_useTextToSpeechOnSilent); + } + + muteTextToSpeechDuringCalls = prefs.getBoolean("muteTextToSpeechDuringCalls", default_muteTextToSpeechDuringCalls); + + positioningEngine = Integer.parseInt(prefs.getString("positioningEngineOption", String.valueOf(default_positioningEngine))); + useWifiForPositioning = prefs.getBoolean("useWifiForPositioning", default_useWifiForPositioning); + useAccelerometerForPositioning = prefs.getBoolean("useAccelerometerForPositioning", default_useAccelerometerForPositioning); + useAccelerometerAfterIdleTime = Long.parseLong(prefs.getString("useAccelerometerAfterIdleTime", String.valueOf(default_useAccelerometerAfterIdleTime))); + accelerometerMovementThreshold = Long.parseLong(prefs.getString("accelerometerMovementThreshold", String.valueOf(default_accelerometerMovementThreshold))); + speedMaximumTimeBetweenLocations = Long.parseLong(prefs.getString("speedMaximumTimeBetweenLocations", String.valueOf(default_speedMaximumTimeBetweenLocations))); + hasServiceBeenRunning = prefs.getBoolean("hasServiceBeenRunning", default_hasServiceBeenRunning); + startServiceAfterAppUpdate = prefs.getBoolean("startServiceAfterAppUpdate", default_startServiceAfterAppUpdate); + startNewThreadForRuleActivation = prefs.getBoolean("startNewThreadForRuleActivation", default_startNewThreadForRuleActivation); + showIconWhenServiceIsRunning = prefs.getBoolean("showIconWhenServiceIsRunning", default_showIconWhenServiceIsRunning); + + minimumDistanceChangeForGpsUpdate = Long.parseLong(prefs.getString("MINIMUM_DISTANCE_CHANGE_FOR_GPS_UPDATE", String.valueOf(default_minimumDistanceChangeForGpsUpdate))); + minimumDistanceChangeForNetworkUpdate = Long.parseLong(prefs.getString("MINIMUM_DISTANCE_CHANGE_FOR_NETWORK_UPDATE", String.valueOf(default_minimumDistanceChangeForNetworkUpdate))); + satisfactoryAccuracyGps = Long.parseLong(prefs.getString("SATISFACTORY_ACCURACY_GPS", String.valueOf(default_satisfactoryAccuracyGps))); + satisfactoryAccuracyNetwork = Long.parseLong(prefs.getString("SATISFACTORY_ACCURACY_NETWORK", String.valueOf(default_satisfactoryAccuracyNetwork))); + gpsTimeout = Integer.parseInt(prefs.getString("gpsTimeout", String.valueOf(default_gpsTimeout))); + minimumTimeBetweenUpdate = Long.parseLong(prefs.getString("MINIMUM_TIME_BETWEEN_UPDATE", String.valueOf(default_minimumTimeBetweenUpdate))); + timeBetweenNoiseLevelMeasurements = Long.parseLong(prefs.getString("timeBetweenNoiseLevelMeasurements", String.valueOf(default_timeBetweenNoiseLevelMeasurements))); + lengthOfNoiseLevelMeasurements = Long.parseLong(prefs.getString("lengthOfNoiseLevelMeasurements", String.valueOf(default_lengthOfNoiseLevelMeasurements))); + referenceValueForNoiseLevelMeasurements = Long.parseLong(prefs.getString("referenceValueForNoiseLevelMeasurements", String.valueOf(default_referenceValueForNoiseLevelMeasurements))); + timeBetweenProcessMonitorings = Long.parseLong(prefs.getString("timeBetweenProcessMonitorings", String.valueOf(default_timeBetweenProcessMonitorings))); + + httpAcceptAllCertificates = prefs.getBoolean("httpAcceptAllCertificates", default_httpAcceptAllCertificates); + httpAttempts = Integer.parseInt(prefs.getString("httpAttempts", String.valueOf(default_httpAttempts))); + httpAttemptsTimeout = Integer.parseInt(prefs.getString("httpAttemptsTimeout", String.valueOf(default_httpAttemptsTimeout))); + httpAttemptGap = Integer.parseInt(prefs.getString("httpAttemptGap", String.valueOf(default_httpAttemptGap))); + + logLevel = Long.parseLong(prefs.getString("logLevel", String.valueOf(default_logLevel))); + logFileMaxSize = Integer.parseInt(prefs.getString("logFileMaxSize", String.valueOf(default_logFileMaxSize))); + + lastActivePoi = default_lastActivePoi; + rememberLastActivePoi = prefs.getBoolean("rememberLastActivePoi", default_rememberLastActivePoi); + + locationRingBufferSize = Integer.parseInt(prefs.getString("locationRingBufferSize", String.valueOf(default_locationRingBufferSize))); + + activityDetectionFrequency = Integer.parseInt(prefs.getString("activityDetectionFrequency", String.valueOf(default_activityDetectionFrequency))); + activityDetectionRequiredProbability = Integer.parseInt(prefs.getString("activityDetectionRequiredProbability", String.valueOf(default_activityDetectionRequiredProbability))); + + privacyLocationing = prefs.getBoolean("privacyLocationing", default_privacyLocationing); + startScreen = Integer.parseInt(prefs.getString("startScreen", String.valueOf(default_startScreen))); + + executeRulesAndProfilesWithSingleClick = prefs.getBoolean("executeRulesAndProfilesWithSingleClick", default_executeRulesAndProfilesWithSingleClick); + + lockSoundChanges = prefs.getBoolean("lockSoundChanges", default_lockSoundChanges); + noticeAndroid9MicrophoneShown = prefs.getBoolean("noticeAndroid9MicrophoneShown", false); + noticeAndroid10WifiShown = prefs.getBoolean("noticeAndroid10WifiShown", false); + } + catch(Exception e) + { + Miscellaneous.logEvent("e", context.getResources().getString(R.string.settings), context.getResources().getString(R.string.errorReadingSettings) + " " + Log.getStackTraceString(e), 1); + + } + finally + { + initializeSettings(context, false); + } + } + + /**Makes sure a settings has a valid setting. If not it will assign a reasonable default setting to it. + * If force settings will be initialized even if the user has set something.**/ + public static boolean initializeSettings(Context context, boolean force) + { + if(force) + eraseSettings(context); + + try + { + Miscellaneous.logEvent("i", context.getResources().getString(R.string.settings), context.getResources().getString(R.string.initializingSettingsToPersistentMemory), 5); + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context); + + Editor editor = prefs.edit(); + + if(!prefs.contains("startServiceAtSystemBoot") | force) + editor.putBoolean("startServiceAtSystemBoot", default_startServiceAtSystemBoot); + + if(!prefs.contains("writeLogFile") | force) + editor.putBoolean("writeLogFile", default_writeLogFile); + +// if(!prefs.contains("useTextToSpeech") | force) +// editor.putBoolean("useTextToSpeech", default_useTextToSpeech); + + if(!prefs.contains("useTextToSpeechOnNormal") | force) + editor.putBoolean("useTextToSpeechOnNormal", default_useTextToSpeechOnNormal); + + if(!prefs.contains("useTextToSpeechOnVibrate") | force) + editor.putBoolean("useTextToSpeechOnVibrate", default_useTextToSpeechOnVibrate); + + if(!prefs.contains("useTextToSpeechOnSilent") | force) + editor.putBoolean("useTextToSpeechOnSilent", default_useTextToSpeechOnSilent); + + if(!prefs.contains("muteTextToSpeechDuringCalls") | force) + editor.putBoolean("muteTextToSpeechDuringCalls", default_muteTextToSpeechDuringCalls); + + if(!prefs.contains("positioningEngine") | force) + editor.putString("positioningEngine", String.valueOf(default_positioningEngine)); + + if(!prefs.contains("useWifiForPositioning") | force) + editor.putBoolean("useWifiForPositioning", default_useWifiForPositioning); + + if(!prefs.contains("hasServiceBeenRunning") | force) + editor.putBoolean("hasServiceBeenRunning", default_hasServiceBeenRunning); + + if(!prefs.contains("startServiceAfterAppUpdate") | force) + editor.putBoolean("startServiceAfterAppUpdate", default_startServiceAfterAppUpdate); + + if(!prefs.contains("startNewThreadForRuleActivation") | force) + editor.putBoolean("startNewThreadForRuleActivation", default_startNewThreadForRuleActivation); + + if(!prefs.contains("showIconWhenServiceIsRunning") | force) + editor.putBoolean("showIconWhenServiceIsRunning", default_showIconWhenServiceIsRunning); + + if(!prefs.contains("useAccelerometerForPositioning") | force) + editor.putBoolean("useAccelerometerForPositioning", default_useAccelerometerForPositioning); + + if(!prefs.contains("useAccelerometerAfterIdleTime") | force) + editor.putString("useAccelerometerAfterIdleTime", String.valueOf(default_useAccelerometerAfterIdleTime)); + + if(!prefs.contains("accelerometerMovementThreshold") | force) + editor.putString("accelerometerMovementThreshold", String.valueOf(default_accelerometerMovementThreshold)); + + if(!prefs.contains("speedMaximumTimeBetweenLocations") | force) + editor.putString("speedMaximumTimeBetweenLocations", String.valueOf(default_speedMaximumTimeBetweenLocations)); + + if(!prefs.contains("MINIMUM_DISTANCE_CHANGE_FOR_GPS_UPDATE") | force) + editor.putString("MINIMUM_DISTANCE_CHANGE_FOR_GPS_UPDATE", String.valueOf(default_minimumDistanceChangeForGpsUpdate)); + + if(!prefs.contains("MINIMUM_DISTANCE_CHANGE_FOR_NETWORK_UPDATE") | force) + editor.putString("MINIMUM_DISTANCE_CHANGE_FOR_NETWORK_UPDATE", String.valueOf(default_minimumDistanceChangeForNetworkUpdate)); + + if(!prefs.contains("SATISFACTORY_ACCURACY_GPS") | force) + editor.putString("SATISFACTORY_ACCURACY_GPS", String.valueOf(default_satisfactoryAccuracyGps)); + + if(!prefs.contains("SATISFACTORY_ACCURACY_NETWORK") | force) + editor.putString("SATISFACTORY_ACCURACY_NETWORK", String.valueOf(default_satisfactoryAccuracyNetwork)); + + if(!prefs.contains("gpsTimeout") | force) + editor.putString("gpsTimeout", String.valueOf(default_gpsTimeout)); + + if(!prefs.contains("MINIMUM_TIME_BETWEEN_UPDATE") | force) + editor.putString("MINIMUM_TIME_BETWEEN_UPDATE", String.valueOf(default_minimumTimeBetweenUpdate)); + + if(!prefs.contains("timeBetweenNoiseLevelMeasurements") | force) + editor.putString("timeBetweenNoiseLevelMeasurements", String.valueOf(default_timeBetweenNoiseLevelMeasurements)); + + if(!prefs.contains("lengthOfNoiseLevelMeasurements") | force) + editor.putString("lengthOfNoiseLevelMeasurements", String.valueOf(default_lengthOfNoiseLevelMeasurements)); + + if(!prefs.contains("referenceValueForNoiseLevelMeasurements") | force) + editor.putString("referenceValueForNoiseLevelMeasurements", String.valueOf(default_referenceValueForNoiseLevelMeasurements)); + + if(!prefs.contains("logLevel") | force) + editor.putString("logLevel", String.valueOf(default_logLevel)); + + if(!prefs.contains("logFileMaxSize") | force) + editor.putString("logFileMaxSize", String.valueOf(default_logFileMaxSize)); + + if(!prefs.contains("httpAcceptAllCertificates") | force) + editor.putBoolean("httpAcceptAllCertificates", default_httpAcceptAllCertificates); + + if(!prefs.contains("httpAttempts") | force) + editor.putString("httpAttempts", String.valueOf(default_httpAttempts)); + + if(!prefs.contains("httpAttemptsTimeout") | force) + editor.putString("httpAttemptsTimeout", String.valueOf(default_httpAttemptsTimeout)); + + if(!prefs.contains("httpAttemptGap") | force) + editor.putString("httpAttemptGap", String.valueOf(default_httpAttemptGap)); + + if(!prefs.contains("lastActivePoi") | force) + editor.putString("lastActivePoi", "null"); + + if(!prefs.contains("rememberLastActivePoi") | force) + editor.putBoolean("rememberLastActivePoi", default_rememberLastActivePoi); + + if(!prefs.contains("locationRingBufferSize") | force) + editor.putString("locationRingBufferSize", String.valueOf(default_locationRingBufferSize)); + + if(!prefs.contains("timeBetweenProcessMonitorings") | force) + editor.putString("timeBetweenProcessMonitorings", String.valueOf(default_timeBetweenProcessMonitorings)); + + if(!prefs.contains("activityDetectionFrequency") | force) + editor.putString("activityDetectionFrequency", String.valueOf(default_activityDetectionFrequency)); + + if(!prefs.contains("activityDetectionRequiredProbability") | force) + editor.putString("activityDetectionRequiredProbability", String.valueOf(default_activityDetectionRequiredProbability)); + + if(!prefs.contains("privacyLocationing") | force) + editor.putBoolean("privacyLocationing", default_privacyLocationing); + + if(!prefs.contains("startScreen") | force) + editor.putString("startScreen", String.valueOf(default_startScreen)); + + if(!prefs.contains("executeRulesAndProfilesWithSingleClick") | force) + editor.putBoolean("executeRulesAndProfilesWithSingleClick", default_executeRulesAndProfilesWithSingleClick); + + if(!prefs.contains("lockSoundChanges") | force) + editor.putBoolean("lockSoundChanges", default_lockSoundChanges); + + if(!prefs.contains("noticeAndroid9MicrophoneShown") | force) + editor.putBoolean("noticeAndroid9MicrophoneShown", false); + + editor.commit(); + + return true; + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", context.getResources().getString(R.string.settings), context.getResources().getString(R.string.errorInitializingSettingsToPersistentMemory), 1); +// eraseSettings(context); + } + return false; + } + + public static void writeSettings(Context context) + { + try + { + Miscellaneous.logEvent("i", context.getResources().getString(R.string.settings), context.getResources().getString(R.string.writingSettingsToPersistentMemory), 5); + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context); + + Editor editor = prefs.edit(); + + editor.putBoolean("startServiceAtSystemBoot", startServiceAtSystemBoot); + editor.putBoolean("writeLogFile", writeLogFile); +// editor.putBoolean("useTextToSpeech", useTextToSpeech); + editor.putBoolean("useTextToSpeechOnNormal", useTextToSpeechOnNormal); + editor.putBoolean("useTextToSpeechOnVibrate", useTextToSpeechOnVibrate); + editor.putBoolean("useTextToSpeechOnSilent", useTextToSpeechOnSilent); + editor.putBoolean("muteTextToSpeechDuringCalls", muteTextToSpeechDuringCalls); + + editor.putString("positioningEngine", String.valueOf(positioningEngine)); + editor.putBoolean("useWifiForPositioning", useWifiForPositioning); + editor.putBoolean("hasServiceBeenRunning", hasServiceBeenRunning); + editor.putBoolean("startServiceAfterAppUpdate", startServiceAfterAppUpdate); + editor.putBoolean("startNewThreadForRuleActivation", startNewThreadForRuleActivation); + editor.putBoolean("showIconWhenServiceIsRunning", showIconWhenServiceIsRunning); + editor.putBoolean("useAccelerometerForPositioning", useAccelerometerForPositioning); + editor.putString("useAccelerometerAfterIdleTime", String.valueOf(useAccelerometerAfterIdleTime)); + editor.putString("accelerometerMovementThreshold", String.valueOf(accelerometerMovementThreshold)); + editor.putString("speedMaximumTimeBetweenLocations", String.valueOf(speedMaximumTimeBetweenLocations)); + editor.putString("MINIMUM_DISTANCE_CHANGE_FOR_GPS_UPDATE", String.valueOf(minimumDistanceChangeForGpsUpdate)); + editor.putString("MINIMUM_DISTANCE_CHANGE_FOR_NETWORK_UPDATE", String.valueOf(minimumDistanceChangeForNetworkUpdate)); + editor.putString("SATISFACTORY_ACCURACY_GPS", String.valueOf(satisfactoryAccuracyGps)); + editor.putString("SATISFACTORY_ACCURACY_NETWORK", String.valueOf(satisfactoryAccuracyNetwork)); + editor.putString("gpsTimeout", String.valueOf(gpsTimeout)); + editor.putString("MINIMUM_TIME_BETWEEN_UPDATE", String.valueOf(minimumTimeBetweenUpdate)); + editor.putString("timeBetweenNoiseLevelMeasurements", String.valueOf(timeBetweenNoiseLevelMeasurements)); + editor.putString("lengthOfNoiseLevelMeasurements", String.valueOf(lengthOfNoiseLevelMeasurements)); + editor.putString("referenceValueForNoiseLevelMeasurements", String.valueOf(referenceValueForNoiseLevelMeasurements)); + editor.putString("logLevel", String.valueOf(logLevel)); + editor.putString("logFileMaxSize", String.valueOf(logFileMaxSize)); + editor.putBoolean("httpAcceptAllCertificates", httpAcceptAllCertificates); + editor.putString("httpAttempts", String.valueOf(httpAttempts)); + editor.putString("httpAttemptsTimeout", String.valueOf(httpAttemptsTimeout)); + editor.putString("httpAttemptGap", String.valueOf(httpAttemptGap)); + editor.putString("locationRingBufferSize", String.valueOf(locationRingBufferSize)); + editor.putString("timeBetweenProcessMonitorings", String.valueOf(timeBetweenProcessMonitorings)); + editor.putString("activityDetectionFrequency", String.valueOf(activityDetectionFrequency)); + editor.putString("activityDetectionRequiredProbability", String.valueOf(activityDetectionRequiredProbability)); + editor.putBoolean("privacyLocationing", privacyLocationing); + editor.putString("startScreen", String.valueOf(startScreen)); + editor.putBoolean("executeRulesAndProfilesWithSingleClick", executeRulesAndProfilesWithSingleClick); + + editor.putBoolean("lockSoundChanges", lockSoundChanges); + editor.putBoolean("noticeAndroid9MicrophoneShown", noticeAndroid9MicrophoneShown); + editor.putBoolean("noticeAndroid10WifiShown", noticeAndroid10WifiShown); + + if(lastActivePoi == null) + editor.putString("lastActivePoi", "null"); + else + editor.putString("lastActivePoi", lastActivePoi.getName()); + + editor.putBoolean("rememberLastActivePoi", rememberLastActivePoi); + + editor.commit(); + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", context.getResources().getString(R.string.settings), context.getResources().getString(R.string.errorWritingSettingsToPersistentMemory), 1); + } + } + + public static boolean eraseSettings(Context context) + { + try + { + Miscellaneous.logEvent("e", context.getResources().getString(R.string.settings), context.getResources().getString(R.string.invalidStuffStoredInSettingsErasing), 1); + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context); + prefs.edit().clear().commit(); + return true; + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", context.getResources().getString(R.string.settings), context.getResources().getString(R.string.errorWritingSettingsToPersistentMemory), 1); + } + return false; + } + + @Override + public Set getStringSet(String arg0, Set arg1) + { + // TODO Auto-generated method stub + return null; + } + +} diff --git a/app/src/main/java/com/jens/automation2/TimeFrame.java b/app/src/main/java/com/jens/automation2/TimeFrame.java new file mode 100644 index 0000000..757d85b --- /dev/null +++ b/app/src/main/java/com/jens/automation2/TimeFrame.java @@ -0,0 +1,75 @@ +package com.jens.automation2; + +import java.sql.Time; +import java.util.ArrayList; + +public class TimeFrame +{ + // Defines a timeframe + private Time triggerTimeStart; + private Time triggerTimeStop; + + private ArrayList dayList = new ArrayList(); + public ArrayList getDayList() + { + return dayList; + } + public void setDayList(ArrayList dayList) + { + this.dayList = dayList; + } + public void setDayListFromString(String dayListString) + { +// Log.i("Parsing", "Full string: " + dayListString); + char[] dayListCharArray = dayListString.toCharArray(); + + dayList = new ArrayList(); + for(char item : dayListCharArray) + { +// Log.i("Parsing", String.valueOf(item)); + dayList.add(Integer.parseInt(String.valueOf(item))); + } + } + + + public Time getTriggerTimeStart() + { + return triggerTimeStart; + } + public void setTriggerTimeStart(Time triggerTimeStart) + { + this.triggerTimeStart = triggerTimeStart; + } + public Time getTriggerTimeStop() + { + return triggerTimeStop; + } + public void setTriggerTimeStop(Time triggerTimeStop) + { + this.triggerTimeStop = triggerTimeStop; + } + + public TimeFrame (Time timeStart, Time timeEnd, ArrayList dayList2) + { + this.setTriggerTimeStart(timeStart); + this.setTriggerTimeStop(timeEnd); + this.setDayList(dayList2); + } + TimeFrame (String fileContent) + { + String[] dateArray = fileContent.split("/"); // example: timestart/timestop/days[int] + this.setTriggerTimeStart(Time.valueOf(dateArray[0])); + this.setTriggerTimeStop(Time.valueOf(dateArray[1])); + this.setDayListFromString(dateArray[2]); + } + @Override + public String toString() + { + String returnString = this.getTriggerTimeStart().toString() + "/" + this.getTriggerTimeStop().toString() + "/"; + + for(Integer oneDay : this.getDayList()) + returnString += String.valueOf(oneDay); + + return returnString; + } +} diff --git a/app/src/main/java/com/jens/automation2/Trigger.java b/app/src/main/java/com/jens/automation2/Trigger.java new file mode 100644 index 0000000..e6e43a8 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/Trigger.java @@ -0,0 +1,479 @@ +package com.jens.automation2; + +import android.bluetooth.BluetoothDevice; +import android.content.Context; + +import com.jens.automation2.receivers.ActivityDetectionReceiver; +import com.jens.automation2.receivers.BluetoothReceiver; + +import java.util.ArrayList; + + +public class Trigger +{ + /* + * Can be several things: + * -PointOfInterest + * -TimeFrame + * -Event (like charging, cable plugged, etc.) + */ + + public enum Trigger_Enum { + pointOfInterest, timeFrame, charging, batteryLevel, usb_host_connection, speed, noiseLevel, wifiConnection, process_started_stopped, airplaneMode, roaming, nfcTag, activityDetection, bluetoothConnection, headsetPlugged, phoneCall; //phoneCall always needs to be at the very end because of Google's shitty so called privacy + + public String getFullName(Context context) + { + switch(this) + { + case pointOfInterest: + return context.getResources().getString(R.string.triggerPointOfInterest); + case timeFrame: + return context.getResources().getString(R.string.triggerTimeFrame); + case charging: + return context.getResources().getString(R.string.triggerCharging); + case batteryLevel: + return context.getResources().getString(R.string.batteryLevel); + case usb_host_connection: + return context.getResources().getString(R.string.triggerUsb_host_connection); + case speed: + return context.getResources().getString(R.string.triggerSpeed); + case noiseLevel: + return context.getResources().getString(R.string.triggerNoiseLevel); + case wifiConnection: + return context.getResources().getString(R.string.wifiConnection); + case process_started_stopped: + return context.getResources().getString(R.string.anotherAppIsRunning); + case airplaneMode: + return context.getResources().getString(R.string.airplaneMode); + case roaming: + return context.getResources().getString(R.string.roaming); + case phoneCall: + return context.getResources().getString(R.string.phoneCall); + case nfcTag: + return context.getResources().getString(R.string.nfcTag); + case activityDetection: + return context.getResources().getString(R.string.activityDetection); + case bluetoothConnection: + return context.getResources().getString(R.string.bluetoothConnection); + case headsetPlugged: + return context.getResources().getString(R.string.triggerHeadsetPlugged); + default: + return "Unknown"; + } + } + + }; + + private boolean triggerParameter; //if true->started event, if false->stopped + + private Trigger_Enum triggerType = null; + private PointOfInterest pointOfInterest = null; + private TimeFrame timeFrame; + + private double speed; //km/h + private long noiseLevelDb; + private String wifiName = ""; + private String processName = null; + private int batteryLevel; + private int phoneDirection = 0; // 0=any, 1=incoming, 2=outgoing + private String phoneNumber = null; + private String nfcTagId = null; + private String bluetoothEvent = null; + private String bluetoothDeviceAddress = null; + private int activityDetectionType = -1; + private int headphoneType = -1; + + public int getHeadphoneType() + { + return headphoneType; + } + public void setHeadphoneType(int headphoneType) + { + this.headphoneType = headphoneType; + } + public String getNfcTagId() + { + return nfcTagId; + } + public void setNfcTagId(String nfcTagId) + { + this.nfcTagId = nfcTagId; + } + + public int getActivityDetectionType() + { + return activityDetectionType; + } + public void setActivityDetectionType(int activityDetectionType) + { + this.activityDetectionType = activityDetectionType; + } + public String getBluetoothDeviceAddress() + { + return bluetoothDeviceAddress; + } + public void setBluetoothDeviceAddress(String bluetoothDeviceAddress) + { + this.bluetoothDeviceAddress = bluetoothDeviceAddress; + } + public void setPhoneNumber(String phoneNumber) + { + this.phoneNumber = phoneNumber; + } + public String getPhoneNumber() + { + return phoneNumber; + } + + public void setPhoneDirection(int phoneDirection) + { + this.phoneDirection = phoneDirection; + } + public int getPhoneDirection() + { + return phoneDirection; + } + + public int getBatteryLevel() + { + return batteryLevel; + } + + public void setBatteryLevel(int batteryLevel) + { + this.batteryLevel = batteryLevel; + } + + public String getProcessName() + { + return processName; + } + + public void setProcessName(String processName) + { + this.processName = processName; + } + + public PointOfInterest getPointOfInterest() + { + return pointOfInterest; + } + + public void setPointOfInterest(PointOfInterest setPointOfInterest) + { + this.pointOfInterest = setPointOfInterest; + } + + public double getSpeed() + { + return speed; + } + + public void setSpeed(double speed) + { + this.speed = speed; + } + + public long getNoiseLevelDb() + { + return noiseLevelDb; + } + + public void setNoiseLevelDb(long noiseLevelDb) + { + this.noiseLevelDb = noiseLevelDb; + } + + public Trigger_Enum getTriggerType() + { + return triggerType; + } + + public void setTriggerType(Trigger_Enum settriggerType) + { + this.triggerType = settriggerType; + } + + public boolean getTriggerParameter() + { + return triggerParameter; + } + + public void setTriggerParameter(boolean triggerParameter) + { + this.triggerParameter = triggerParameter; + } + + public TimeFrame getTimeFrame() + { + return timeFrame; + } + + public void setTimeFrame(TimeFrame timeFrame) + { + this.timeFrame = timeFrame; + } + + + @SuppressWarnings("unused") + @Override + public String toString() + { + StringBuilder returnString = new StringBuilder(); + + /* + * public enum TriggerType_Enum { pointOfInterest, timeFrame, event }; + public enum Event_Enum { charging_started, charging_stopped, usb_connected, usb_disconnected }; + + private TriggerType_Enum triggerType; + private PointOfInterest pointOfInterest; + private Event_Enum event; + private TimeFrame timeFrame; + */ + + switch(this.getTriggerType()) + { + case charging: + if(getTriggerParameter()) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.starting) + " "); + else + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.stopping) + " "); + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.triggerCharging)); + break; + case batteryLevel: + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.batteryLevel)); + if(getTriggerParameter()) + returnString.append(" " + Miscellaneous.getAnyContext().getResources().getString(R.string.exceeds) + " "); + else + returnString.append(" " + Miscellaneous.getAnyContext().getResources().getString(R.string.dropsBelow) + " "); + returnString.append(String.valueOf(this.getBatteryLevel()) + " %"); + break; + case usb_host_connection: + if(getTriggerParameter()) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.connecting) + " "); + else + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.disconnecting) + " "); + + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.triggerUsb_host_connection)); + break; + case pointOfInterest: + if(this.getPointOfInterest() != null) + { + if(getTriggerParameter()) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.entering) + " "); + else + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.leaving) + " "); + + returnString.append(this.getPointOfInterest().getName().toString()); + } + else + { + if(getTriggerParameter()) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.leaving) + " " + Miscellaneous.getAnyContext().getResources().getString(R.string.anyLocation)); + else + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.entering) + " " + Miscellaneous.getAnyContext().getResources().getString(R.string.anyLocation)); + } + break; + case timeFrame: + if(getTriggerParameter()) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.entering) + " "); + else + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.leaving) + " "); + + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.triggerTimeFrame) + ": " + this.getTimeFrame().getTriggerTimeStart().toString() + " " + Miscellaneous.getAnyContext().getResources().getString(R.string.until) + " " + this.getTimeFrame().getTriggerTimeStop().toString() + " on days " + this.getTimeFrame().getDayList().toString()); + break; + case speed: + if(getTriggerParameter()) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.exceeding) + " "); + else + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.droppingBelow) + " "); + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.triggerSpeed) + ": " + String.valueOf(this.getSpeed()) + " km/h"); + break; + case noiseLevel: + if(getTriggerParameter()) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.exceeding) + " "); + else + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.droppingBelow) + " "); + + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.triggerNoiseLevel) + ": " + String.valueOf(this.getNoiseLevelDb()) + " dB"); + break; + case wifiConnection: + String wifiDisplayName = ""; + if(this.getWifiName().length() == 0) + wifiDisplayName += Miscellaneous.getAnyContext().getResources().getString(R.string.anyWifi); + else + wifiDisplayName += this.getWifiName(); + + if(getTriggerParameter()) + returnString.append(String.format(Miscellaneous.getAnyContext().getResources().getString(R.string.connectedToWifi), wifiDisplayName)); + else + returnString.append(String.format(Miscellaneous.getAnyContext().getResources().getString(R.string.disconnectedFromWifi), wifiDisplayName)); + + break; + case process_started_stopped: + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.application) + " " + this.getProcessName() + " " + Miscellaneous.getAnyContext().getResources().getString(R.string.is) + " "); + if(this.triggerParameter) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.started)); + else + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.stopped)); + break; + case airplaneMode: + if(getTriggerParameter()) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.activated) + " "); + else + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.deactivated) + " "); + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.airplaneMode)); + break; + case roaming: + if(getTriggerParameter()) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.activated) + " "); + else + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.deactivated) + " "); + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.roaming)); + break; + case phoneCall: + if(getPhoneDirection() == 1) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.incomingAdjective) + " "); + else if(getPhoneDirection() == 2) + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.outgoingAdjective) + " "); + + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.phoneCall)); + if(phoneNumber != null && !phoneNumber.equals("any")) + returnString.append(" " + Miscellaneous.getAnyContext().getResources().getString(R.string.with) + " " + Miscellaneous.getAnyContext().getResources().getString(R.string.number) + " " + phoneNumber); + else + returnString.append(" " + Miscellaneous.getAnyContext().getResources().getString(R.string.with) + " " + Miscellaneous.getAnyContext().getResources().getString(R.string.anyNumber)); + + if(getTriggerParameter()) + returnString.append(" " + Miscellaneous.getAnyContext().getResources().getString(R.string.started)); + else + returnString.append(" " + Miscellaneous.getAnyContext().getResources().getString(R.string.stopped)); + break; + case nfcTag: + // This type doesn't have an activate/deactivate equivalent +// if(getTriggerParameter()) +// returnString += Miscellaneous.getAnyContext().getResources().getString(R.string.activated) + " "; +// else +// returnString += Miscellaneous.getAnyContext().getResources().getString(R.string.deactivated) + " "; + + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.closeTo) + " " + Miscellaneous.getAnyContext().getResources().getString(R.string.nfcTag) + " " + Miscellaneous.getAnyContext().getResources().getString(R.string.withLabel) + " " + this.getNfcTagId()); + break; + case activityDetection: + // This type doesn't have an activate/deactivate equivalent, at least not yet. + returnString.append(Miscellaneous.getAnyContext().getResources().getString(R.string.detectedActivity) + " " + ActivityDetectionReceiver.getDescription(getActivityDetectionType())); + break; + case bluetoothConnection: + String device = Miscellaneous.getAnyContext().getResources().getString(R.string.anyDevice); +// if(this.bluetoothDeviceAddress != null) +// { + if(bluetoothDeviceAddress.equals("")) + { + device = Miscellaneous.getAnyContext().getResources().getString(R.string.any); + } + else if(bluetoothDeviceAddress.equals("")) + { + device = Miscellaneous.getAnyContext().getResources().getString(R.string.noDevice); + } + else + { + try + { + device = BluetoothReceiver.getDeviceByAddress(bluetoothDeviceAddress).getName() + " (" + this.bluetoothDeviceAddress + ")"; + } + catch(NullPointerException e) + { + device = Miscellaneous.getAnyContext().getResources().getString(R.string.invalidDevice); + Miscellaneous.logEvent("w", "Trigger", Miscellaneous.getAnyContext().getResources().getString(R.string.invalidDevice), 3); + } + } + + if(bluetoothEvent.equals(BluetoothDevice.ACTION_ACL_CONNECTED) | bluetoothEvent.equals(BluetoothDevice.ACTION_ACL_DISCONNECTED)) + if(this.triggerParameter) + returnString.append(String.format(Miscellaneous.getAnyContext().getResources().getString(R.string.bluetoothConnectionTo), device)); + else + returnString.append(String.format(Miscellaneous.getAnyContext().getResources().getString(R.string.bluetoothDisconnectFrom), device)); + else if(bluetoothEvent.equals(BluetoothDevice.ACTION_FOUND)) + if(this.triggerParameter) + returnString.append(String.format(Miscellaneous.getAnyContext().getResources().getString(R.string.bluetoothDeviceInRange), device)); + else + returnString.append(String.format(Miscellaneous.getAnyContext().getResources().getString(R.string.bluetoothDeviceOutOfRange), device)); +// } + break; + case headsetPlugged: + String type; + switch(headphoneType) + { + case 0: + type = Miscellaneous.getAnyContext().getResources().getString(R.string.headphoneSimple); + break; + case 1: + type = Miscellaneous.getAnyContext().getResources().getString(R.string.headphoneMicrophone); + break; + case 2: + type = Miscellaneous.getAnyContext().getResources().getString(R.string.headphoneAny); + break; + default: + type = "not set"; + break; + } + if(getTriggerParameter()) + returnString.append(String.format(Miscellaneous.getAnyContext().getResources().getString(R.string.headsetConnected), type)); + else + returnString.append(String.format(Miscellaneous.getAnyContext().getResources().getString(R.string.headsetDisconnected), type)); + break; + default: + returnString.append("error"); + break; + } + + return returnString.toString(); + } + + + public static String[] getTriggerTypesAsArray() + { + ArrayList triggerTypesList = new ArrayList(); + + /*for(int i=0; i triggerTypesList = new ArrayList(); + + /*for(int i=0; i + // serializer.attribute(null, "attribute", "value"); + // serializer.endTag(null, "location"); + + serializer.startTag(null, "radius"); + serializer.text(String.valueOf(PointOfInterest.getPointOfInterestCollection().get(i).getRadius())); + serializer.endTag(null, "radius"); + + serializer.endTag(null, "PointOfInterest"); + } + serializer.endTag(null, "PointOfInterestCollection"); + + + serializer.startTag(null, "ProfileCollection"); + for(int i=0; i ruleCollection = new ArrayList(); + public static void parseSettingsFile(InputStream in) throws XmlPullParserException, IOException + { + try + { + XmlPullParser parser = Xml.newPullParser(); + parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, false); + parser.setInput(in, null); + parser.nextTag(); + + XmlFileInterface.readFile3(parser); + } + finally + { + in.close(); + } + } + + protected static String ns=""; + private static void readFile3(XmlPullParser parser) throws XmlPullParserException, IOException + { + Miscellaneous.logEvent("i", "File", "Reading settings file", 4); + parser.require(XmlPullParser.START_TAG, ns, "Automation"); + while (parser.next() != XmlPullParser.END_TAG) + { + if (parser.getEventType() != XmlPullParser.START_TAG) + { + continue; + } + String name = parser.getName(); + // Starts by looking for the entry tag + if (name.equals("PointOfInterestCollection")) + { + PointOfInterest.getPointOfInterestCollection().clear(); + readPoiCollection(parser); + } + else if (name.equals("ProfileCollection")) + { + Profile.getProfileCollection().clear(); + readProfileCollection(parser); + } + else if (name.equals("RuleCollection")) + { + XmlFileInterface.ruleCollection.clear(); + readRuleCollection(parser); + } + else + { + skip(parser); + } + } + Miscellaneous.logEvent("i", "File", "Reading settings file->done", 4); + } + + private static void readPoiCollection(XmlPullParser parser) throws XmlPullParserException, IOException + { + parser.require(XmlPullParser.START_TAG, ns, "PointOfInterestCollection"); + PointOfInterest newPoi = null; + + while (parser.next() != XmlPullParser.END_TAG) + { + if (parser.getEventType() != XmlPullParser.START_TAG) + { + continue; + } + String name = parser.getName(); + if (name.equals("PointOfInterest")) + { + newPoi = new PointOfInterest(); + newPoi = readPoi(parser); + PointOfInterest.getPointOfInterestCollection().add(newPoi); + } + else + { + skip(parser); + } + } + + Collections.sort(PointOfInterest.getPointOfInterestCollection()); + + if(newPoi != null) + Miscellaneous.logEvent("i", "New POI from file", newPoi.toString(), 5); + else + Miscellaneous.logEvent("i", "File", "No POIs in file.", 4); + } + + // Parses the contents of an entry. If it encounters a title, summary, or link tag, hands them off + // to their respective "read" methods for processing. Otherwise, skips the tag. + private static PointOfInterest readPoi(XmlPullParser parser) throws XmlPullParserException, IOException + { + parser.require(XmlPullParser.START_TAG, ns, "PointOfInterest"); + PointOfInterest newPoi = new PointOfInterest(); +// newPoi.parentService = (AutomationService)context; + newPoi.setLocation(new Location("POINT_LOCATION")); + + while (parser.next() != XmlPullParser.END_TAG) + { + if (parser.getEventType() != XmlPullParser.START_TAG) + { + continue; + } + String name = parser.getName(); + if (name.equals("name")) + { + newPoi.setName(readTag(parser, "name")); + + // This checks if the last activated POI + if(Settings.rememberLastActivePoi) + if(newPoi.getName().equals(Settings.lastActivePoi)) + newPoi.setActivated(true); + } + else if (name.equals("latitude")) + { + newPoi.getLocation().setLatitude(Double.valueOf(readTag(parser, "latitude"))); + } + else if (name.equals("longitude")) + { + newPoi.getLocation().setLongitude(Double.valueOf(readTag(parser, "longitude"))); + } + else if (name.equals("radius")) + { + try + { + newPoi.setRadius(Double.valueOf(readTag(parser, "radius")), context); + } + catch (NumberFormatException e) + { + e.printStackTrace(); + } + catch (Exception e) + { + e.printStackTrace(); + } + } + else + { + skip(parser); + } + } + + Miscellaneous.logEvent("i", "New POI from file", newPoi.toStringLong(), 5); + + return newPoi; + } + + private static void readProfileCollection(XmlPullParser parser) throws XmlPullParserException, IOException + { + parser.require(XmlPullParser.START_TAG, ns, "ProfileCollection"); + Profile newProfile = null; + + while (parser.next() != XmlPullParser.END_TAG) + { + if (parser.getEventType() != XmlPullParser.START_TAG) + { + continue; + } + String name = parser.getName(); + if (name.equals("Profile")) + { + newProfile = new Profile(); + newProfile = readProfile(parser); + Profile.getProfileCollection().add(newProfile); + } + else + { + skip(parser); + } + } + + Collections.sort(Profile.getProfileCollection()); + + if(newProfile != null) + Miscellaneous.logEvent("i", "New Profile from file", newProfile.toString(), 5); + else + Miscellaneous.logEvent("i", "File", "No Profiles in file.", 4); + } + + private static Profile readProfile(XmlPullParser parser) throws XmlPullParserException, IOException + { + parser.require(XmlPullParser.START_TAG, ns, "Profile"); + Profile newProfile = new Profile(); + + while (parser.next() != XmlPullParser.END_TAG) + { + if (parser.getEventType() != XmlPullParser.START_TAG) + { + continue; + } + String name = parser.getName(); + + if (name.equals("name")) + newProfile.setName(readTag(parser, "name")); + else if (name.equals("changeSoundMode")) + newProfile.setChangeSoundMode(Boolean.parseBoolean(readTag(parser, "changeSoundMode"))); + else if (name.equals("soundMode")) + newProfile.setSoundMode(Integer.parseInt(readTag(parser, "soundMode"))); + else if (name.equals("changeVolumeMusicVideoGameMedia")) + newProfile.setChangeVolumeMusicVideoGameMedia(Boolean.parseBoolean(readTag(parser, "changeVolumeMusicVideoGameMedia"))); + else if (name.equals("volumeMusic")) + newProfile.setVolumeMusic(Integer.parseInt(readTag(parser, "volumeMusic"))); + else if (name.equals("changeVolumeNotifications")) + newProfile.setChangeVolumeNotifications(Boolean.parseBoolean(readTag(parser, "changeVolumeNotifications"))); + else if (name.equals("volumeNotifications")) + newProfile.setVolumeNotifications(Integer.parseInt(readTag(parser, "volumeNotifications"))); + else if (name.equals("changeVolumeAlarms")) + newProfile.setChangeVolumeAlarms(Boolean.parseBoolean(readTag(parser, "changeVolumeAlarms"))); + else if (name.equals("volumeAlarms")) + newProfile.setVolumeAlarms(Integer.parseInt(readTag(parser, "volumeAlarms"))); + else if (name.equals("changeIncomingCallsRingtone")) + newProfile.setChangeIncomingCallsRingtone(Boolean.parseBoolean(readTag(parser, "changeIncomingCallsRingtone"))); + else if (name.equals("incomingCallsRingtone")) + { + String path = readTag(parser, "incomingCallsRingtone"); + if(!path.equals("null")) + newProfile.setIncomingCallsRingtone(new File(path)); + else + newProfile.setIncomingCallsRingtone(null); + } + else if (name.equals("changeVibrateWhenRinging")) + newProfile.setChangeVibrateWhenRinging(Boolean.parseBoolean(readTag(parser, "changeVibrateWhenRinging"))); + else if (name.equals("changeNotificationRingtone")) + newProfile.setChangeNotificationRingtone(Boolean.parseBoolean(readTag(parser, "changeNotificationRingtone"))); + else if (name.equals("notificationRingtone")) + { + String path = readTag(parser, "notificationRingtone"); + if(!path.equals("null")) + newProfile.setNotificationRingtone(new File(path)); + else + newProfile.setNotificationRingtone(null); + } + else if (name.equals("changeAudibleSelection")) + newProfile.setChangeAudibleSelection(Boolean.parseBoolean(readTag(parser, "changeAudibleSelection"))); + else if (name.equals("audibleSelection")) + newProfile.setAudibleSelection(Boolean.parseBoolean(readTag(parser, "audibleSelection"))); + else if (name.equals("changeScreenLockUnlockSound")) + newProfile.setChangeScreenLockUnlockSound(Boolean.parseBoolean(readTag(parser, "changeScreenLockUnlockSound"))); + else if (name.equals("screenLockUnlockSound")) + newProfile.setScreenLockUnlockSound(Boolean.parseBoolean(readTag(parser, "screenLockUnlockSound"))); + else if (name.equals("changeHapticFeedback")) + newProfile.setChangeHapticFeedback(Boolean.parseBoolean(readTag(parser, "changeHapticFeedback"))); + else if (name.equals("hapticFeedback")) + newProfile.setHapticFeedback(Boolean.parseBoolean(readTag(parser, "hapticFeedback"))); + else + skip(parser); + + } + + Miscellaneous.logEvent("i", "New Profile from file", newProfile.toStringLong(), 5); + + return newProfile; + } + + private static void readRuleCollection(XmlPullParser parser) throws XmlPullParserException, IOException + { + Miscellaneous.logEvent("i", "File", "Reading Rule Collection from file", 5); + + parser.require(XmlPullParser.START_TAG, ns, "RuleCollection"); + while (parser.next() != XmlPullParser.END_TAG) + { + if (parser.getEventType() != XmlPullParser.START_TAG) + { + continue; + } + String name = parser.getName(); + // Starts by looking for the entry tag + if (name.equals("Rule")) + { + Rule newRule = readRule(parser); + XmlFileInterface.ruleCollection.add(newRule); + } + else + { + skip(parser); + } + } + Collections.sort(XmlFileInterface.ruleCollection); + Miscellaneous.logEvent("i", "File", "Reading Rule Collection from file->done", 5); + } + + private static Rule readRule(XmlPullParser parser) throws XmlPullParserException, IOException + { + /* FILE EXAMPE: + * ***************** + * + * + * + someName + someLatitude + someLongitude + someRadius + * + * + * + * + * String + * true/false + * + * + * String: pointOfInterest, timeFrame, charging, usb_connection + * true/false + * POI-Name, TimeFrame, USB-Device-Name + * + * + * + * + * String + * String + * + * + * + * + * + */ + + parser.require(XmlPullParser.START_TAG, ns, "Rule"); + Rule newRule = new Rule(); + + while (parser.next() != XmlPullParser.END_TAG) + { + if (parser.getEventType() != XmlPullParser.START_TAG) + { + continue; + } + String name = parser.getName(); + if (name.equals("Name")) + { + newRule.setName(readTag(parser, "Name")); + } + else if(name.equals("RuleActive")) + { + newRule.setRuleActive(Boolean.valueOf(readTag(parser, "RuleActive"))); + } + else if(name.equals("RuleToggle")) + { + newRule.setRuleToggle(Boolean.valueOf(readTag(parser, "RuleToggle"))); + } + else if (name.equals("TriggerCollection")) + { + try + { + newRule.setTriggerSet(readTriggerCollection(parser)); + } + catch (XmlPullParserException e) + { + // TODO Auto-generated catch block + e.printStackTrace(); + } + catch (IOException e) + { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + else if (name.equals("ActionCollection")) + { + try + { + newRule.setActionSet(readActionCollection(parser)); + } + catch (XmlPullParserException e) + { + // TODO Auto-generated catch block + e.printStackTrace(); + } + catch (IOException e) + { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + else + { + skip(parser); + } + } + + Miscellaneous.logEvent("i", "New Rule from file", newRule.toString(), 5); + + return newRule; + } + + private static ArrayList readTriggerCollection(XmlPullParser parser) throws XmlPullParserException, IOException + { + ArrayList triggerCollection = new ArrayList(); + + parser.require(XmlPullParser.START_TAG, ns, "TriggerCollection"); + while (parser.next() != XmlPullParser.END_TAG) + { + if (parser.getEventType() != XmlPullParser.START_TAG) + { + continue; + } + String name = parser.getName(); + // Starts by looking for the entry tag + if (name.equals("Trigger")) + { + triggerCollection.add(readTrigger(parser)); + } + else + { + skip(parser); + } + } + + return (triggerCollection); + } + + + private static Trigger readTrigger(XmlPullParser parser) throws IOException, XmlPullParserException + { + + /* FILE EXAMPE: + * ***************** + * + * + * + someName + someLatitude + someLongitude + someRadius + * + * + * + * + * String + * true/false + * + * + * String: pointOfInterest, timeFrame, charging, usb_connection + * true/false + * POI-Name, TimeFrame, USB-Device-Name, Speed + * + * + * + * + * String + * String + * + * + * + * + * + */ + + parser.require(XmlPullParser.START_TAG, ns, "Trigger"); + Trigger newTrigger = new Trigger(); + + while (parser.next() != XmlPullParser.END_TAG) + { + if (parser.getEventType() != XmlPullParser.START_TAG) + { + continue; + } + String name = parser.getName(); + + if (name.equals("TriggerEvent")) + { + String triggerEventString = readTag(parser, "TriggerEvent"); + if(triggerEventString.equals("pointOfInterest")) + newTrigger.setTriggerType(Trigger_Enum.pointOfInterest); + else if(triggerEventString.equals("timeFrame")) + newTrigger.setTriggerType(Trigger_Enum.timeFrame); + else if(triggerEventString.equals("charging")) + newTrigger.setTriggerType(Trigger_Enum.charging); + else if(triggerEventString.equals("usb_host_connection")) + newTrigger.setTriggerType(Trigger_Enum.usb_host_connection); + else if(triggerEventString.equals("batteryLevel")) + newTrigger.setTriggerType(Trigger_Enum.batteryLevel); + else if(triggerEventString.equals("speed")) + newTrigger.setTriggerType(Trigger_Enum.speed); + else if(triggerEventString.equals("noiseLevel")) + newTrigger.setTriggerType(Trigger_Enum.noiseLevel); + else if(triggerEventString.equals("wifiConnection")) + newTrigger.setTriggerType(Trigger_Enum.wifiConnection); + else if(triggerEventString.equals("process_started_stopped") | triggerEventString.equals("process_running")) + newTrigger.setTriggerType(Trigger_Enum.process_started_stopped); + else if(triggerEventString.equals("airplaneMode")) + newTrigger.setTriggerType(Trigger_Enum.airplaneMode); + else if(triggerEventString.equals("roaming")) + newTrigger.setTriggerType(Trigger_Enum.roaming); + else if(triggerEventString.equals("phoneCall")) + newTrigger.setTriggerType(Trigger_Enum.phoneCall); + else if(triggerEventString.equals("nfcTag")) + newTrigger.setTriggerType(Trigger_Enum.nfcTag); + else if(triggerEventString.equals("activityDetection")) + newTrigger.setTriggerType(Trigger_Enum.activityDetection); + else if(triggerEventString.equals("bluetoothConnection")) + newTrigger.setTriggerType(Trigger_Enum.bluetoothConnection); + else if(triggerEventString.equals("headsetPlugged")) + newTrigger.setTriggerType(Trigger_Enum.headsetPlugged); + } + else if (name.equals("TriggerParameter1")) + { + newTrigger.setTriggerParameter(Boolean.valueOf(readTag(parser, "TriggerParameter1"))); + } + else if (name.equals("TriggerParameter2")) + { + String triggerParameter2 = readTag(parser, "TriggerParameter2"); + if(newTrigger.getTriggerType() == Trigger_Enum.pointOfInterest) + { + try + { + if(triggerParameter2.equals("null")) + newTrigger.setPointOfInterest(null); + else + newTrigger.setPointOfInterest(PointOfInterest.getByName(triggerParameter2)); + } + catch (Exception e) + { + Miscellaneous.logEvent("e", "XmlFileInterface", Log.getStackTraceString(e), 2); + Toast.makeText(context, "Error while writing file: " + Log.getStackTraceString(e), Toast.LENGTH_LONG).show(); + } + } + else if(newTrigger.getTriggerType() == Trigger_Enum.timeFrame) + { + newTrigger.setTimeFrame(new TimeFrame(triggerParameter2)); + } + else if(newTrigger.getTriggerType() == Trigger_Enum.batteryLevel) + { + newTrigger.setBatteryLevel(Integer.parseInt(triggerParameter2)); + } + else if(newTrigger.getTriggerType() == Trigger_Enum.speed) + { + newTrigger.setSpeed(Double.parseDouble(triggerParameter2)); + } + else if(newTrigger.getTriggerType() == Trigger_Enum.noiseLevel) + { + newTrigger.setNoiseLevelDb(Long.parseLong(triggerParameter2)); + } + else if(newTrigger.getTriggerType() == Trigger_Enum.wifiConnection) + { + newTrigger.setWifiName(triggerParameter2); + } + else if(newTrigger.getTriggerType() == Trigger_Enum.process_started_stopped) + { + newTrigger.setProcessName(triggerParameter2); + } + else if(newTrigger.getTriggerType() == Trigger_Enum.phoneCall) + { + // 0/1/2,number + int direction = Integer.parseInt(triggerParameter2.substring(0, 1)); + String number = triggerParameter2.substring(2); + newTrigger.setPhoneDirection(direction); + newTrigger.setPhoneNumber(number); + } + else if(newTrigger.getTriggerType() == Trigger_Enum.nfcTag) + { + newTrigger.setNfcTagId(triggerParameter2); + } + else if(newTrigger.getTriggerType() == Trigger_Enum.activityDetection) + { + try + { + newTrigger.setActivityDetectionType(Integer.parseInt(triggerParameter2)); + } + catch(NumberFormatException e) + { + newTrigger.setActivityDetectionType(0); + } + } + else if(newTrigger.getTriggerType() == Trigger_Enum.bluetoothConnection) + { + if(triggerParameter2.contains(";")) + { + String[] substrings = triggerParameter2.split(";"); + newTrigger.setBluetoothEvent(substrings[0]); + newTrigger.setBluetoothDeviceAddress(substrings[1]); + } + } + else if(newTrigger.getTriggerType() == Trigger_Enum.headsetPlugged) + { + try + { + newTrigger.setHeadphoneType(Integer.parseInt(triggerParameter2)); + } + catch(NumberFormatException e) + { + newTrigger.setHeadphoneType(-1); + } + } + } + else + { + skip(parser); + } + } + + return newTrigger; + } + + private static ArrayList readActionCollection(XmlPullParser parser) throws XmlPullParserException, IOException + { + ArrayList actionCollection = new ArrayList(); + + parser.require(XmlPullParser.START_TAG, ns, "ActionCollection"); + while (parser.next() != XmlPullParser.END_TAG) + { + if (parser.getEventType() != XmlPullParser.START_TAG) + { + continue; + } + String name = parser.getName(); + // Starts by looking for the entry tag + if (name.equals("Action")) + { + actionCollection.add(readAction(parser)); + } + else + { + skip(parser); + } + } + return (actionCollection); + } + + + private static Action readAction(XmlPullParser parser) throws IOException, XmlPullParserException + { + /* FILE EXAMPE: + * ***************** + * + * + * + someName + someLatitude + someLongitude + someRadius + * + * + * + * + * String + * true/false + * + * + * String: pointOfInterest, timeFrame, charging, usb_connection + * true/false + * POI-Name, TimeFrame, USB-Device-Name + * + * + * + * + * String + * String + * String + * + * + * + * + * + */ + + parser.require(XmlPullParser.START_TAG, ns, "Action"); + Action newAction = new Action(); + + while (parser.next() != XmlPullParser.END_TAG) + { + if (parser.getEventType() != XmlPullParser.START_TAG) + { + continue; + } + String name = parser.getName(); + + if (name.equals("ActionName")) // convert legacy stuff to new format + { + String actionNameString = readTag(parser, "ActionName"); + + if(actionNameString.equals("setWifi")) + newAction.setAction(Action_Enum.setWifi); + else if(actionNameString.equals("setBluetooth")) + newAction.setAction(Action_Enum.setBluetooth); + else if(actionNameString.equals("setUsbTethering")) + newAction.setAction(Action_Enum.setUsbTethering); + else if(actionNameString.equals("setWifiTethering")) + newAction.setAction(Action_Enum.setWifiTethering); + else if(actionNameString.equals("setDisplayRotation")) + newAction.setAction(Action_Enum.setDisplayRotation); + + // *** deprecated + else if(actionNameString.equals("turnWifiOn")) + newAction.setAction(Action_Enum.turnWifiOn); + else if(actionNameString.equals("turnWifiOff")) + newAction.setAction(Action_Enum.turnWifiOff); + else if(actionNameString.equals("turnBluetoothOn")) + newAction.setAction(Action_Enum.turnBluetoothOn); + else if(actionNameString.equals("turnBluetoothOff")) + newAction.setAction(Action_Enum.turnBluetoothOff); + else if(actionNameString.equals("turnUsbTetheringOn")) + newAction.setAction(Action_Enum.turnUsbTetheringOn); + else if(actionNameString.equals("turnUsbTetheringOff")) + newAction.setAction(Action_Enum.turnUsbTetheringOff); + else if(actionNameString.equals("turnWifiTetheringOn")) + newAction.setAction(Action_Enum.turnWifiTetheringOn); + else if(actionNameString.equals("turnWifiTetheringOff")) + newAction.setAction(Action_Enum.turnWifiTetheringOff); + else if(actionNameString.equals("enableScreenRotation")) + newAction.setAction(Action_Enum.enableScreenRotation); + else if(actionNameString.equals("disableScreenRotation")) + newAction.setAction(Action_Enum.disableScreenRotation); + // *** deprecated + + else if(actionNameString.equals("triggerUrl")) + newAction.setAction(Action_Enum.triggerUrl); + else if(actionNameString.equals("changeSoundProfile")) + newAction.setAction(Action_Enum.changeSoundProfile); + else if(actionNameString.equals("startOtherActivity")) + newAction.setAction(Action_Enum.startOtherActivity); + else if(actionNameString.equals("waitBeforeNextAction")) + newAction.setAction(Action_Enum.waitBeforeNextAction); + else if(actionNameString.equals("wakeupDevice")) + newAction.setAction(Action_Enum.wakeupDevice); + else if(actionNameString.equals("setAirplaneMode")) + newAction.setAction(Action_Enum.setAirplaneMode); + else if(actionNameString.equals("setDataConnection")) + newAction.setAction(Action_Enum.setDataConnection); + else if(actionNameString.equals("speakText")) + newAction.setAction(Action_Enum.speakText); + else if(actionNameString.equals("sendTextMessage")) + newAction.setAction(Action_Enum.sendTextMessage); + else if(actionNameString.equals("playMusic")) + newAction.setAction(Action_Enum.playMusic); + else if(actionNameString.equals("setScreenBrightness")) + newAction.setAction(Action_Enum.setScreenBrightness); + } + else if (name.equals("ActionParameter1")) + { + // exclusion for deprecated types + if(newAction.getAction().equals(Action_Enum.turnWifiOn)) + { + newAction.setAction(Action_Enum.setWifi); + newAction.setParameter1(true); + readTag(parser, "ActionParameter1"); //read the tag for the parser to head on + } + else if(newAction.getAction().equals(Action_Enum.turnWifiOff)) + { + newAction.setAction(Action_Enum.setWifi); + newAction.setParameter1(false); + readTag(parser, "ActionParameter1"); //read the tag for the parser to head on + } + else if(newAction.getAction().equals(Action_Enum.turnBluetoothOn)) + { + newAction.setAction(Action_Enum.setBluetooth); + newAction.setParameter1(true); + readTag(parser, "ActionParameter1"); //read the tag for the parser to head on + } + else if(newAction.getAction().equals(Action_Enum.turnBluetoothOff)) + { + newAction.setAction(Action_Enum.setBluetooth); + newAction.setParameter1(false); + readTag(parser, "ActionParameter1"); //read the tag for the parser to head on + } + else if(newAction.getAction().equals(Action_Enum.turnUsbTetheringOn)) + { + newAction.setAction(Action_Enum.setUsbTethering); + newAction.setParameter1(true); + readTag(parser, "ActionParameter1"); //read the tag for the parser to head on + } + else if(newAction.getAction().equals(Action_Enum.turnUsbTetheringOff)) + { + newAction.setAction(Action_Enum.setUsbTethering); + newAction.setParameter1(false); + readTag(parser, "ActionParameter1"); //read the tag for the parser to head on + } + else if(newAction.getAction().equals(Action_Enum.turnWifiTetheringOn)) + { + newAction.setAction(Action_Enum.setWifiTethering); + newAction.setParameter1(true); + readTag(parser, "ActionParameter1"); //read the tag for the parser to head on + } + else if(newAction.getAction().equals(Action_Enum.turnWifiTetheringOff)) + { + newAction.setAction(Action_Enum.setWifiTethering); + newAction.setParameter1(false); + readTag(parser, "ActionParameter1"); //read the tag for the parser to head on + } + else if(newAction.getAction().equals(Action_Enum.enableScreenRotation)) + { + newAction.setAction(Action_Enum.setDisplayRotation); + newAction.setParameter1(true); + readTag(parser, "ActionParameter1"); //read the tag for the parser to head on + } + else if(newAction.getAction().equals(Action_Enum.disableScreenRotation)) + { + newAction.setAction(Action_Enum.setDisplayRotation); + newAction.setParameter1(false); + readTag(parser, "ActionParameter1"); //read the tag for the parser to head on + } + else + // exclusion for deprecated types + newAction.setParameter1(Boolean.parseBoolean(readTag(parser, "ActionParameter1"))); + } + else if (name.equals("ActionParameter2")) + { + String tag = readTag(parser, "ActionParameter2"); + if(newAction.getAction().equals(Action_Enum.triggerUrl)) // decrypt url because of credentials + { + if(tag.toLowerCase().contains("http")) // not encrypted, yet + newAction.setParameter2(tag); + else + { + try + { + newAction.setParameter2(AESCrypt.decrypt(encryptionKey, tag)); + } + catch(GeneralSecurityException e) + { + newAction.setParameter2(tag); + } + } + } + else + newAction.setParameter2(tag); + } + else if (name.equals("ActionParameter")) // old version, should be removed eventually + { + newAction.setParameter2(readTag(parser, "ActionParameter")); + } + else + { + skip(parser); + } + + if(newAction.getAction().equals(Action_Enum.changeSoundProfile)) + { + String[] replacements = new String[] { "silent", "vibrate", "normal" }; + for(String s : replacements) + { + if(newAction.getParameter2().equals(s) && Profile.getByName(s) == null) // using an old profile name and there is no backing new profile by the same name + Profile.createDummyProfile(context, s); + } + } + } + +// Miscellaneous.logEvent("i", "New Rule from file", newPoi.name + "/" + String.valueOf(newPoi.radius) + "/" + String.valueOf(newPoi.location.getLatitude()) + "/" + String.valueOf(newPoi.location.getLongitude()) + "/" + String.valueOf(newPoi.changeWifiState) + "/" + String.valueOf(newPoi.desiredWifiState) + "/" + String.valueOf(newPoi.changeCameraState) + "/" + String.valueOf(newPoi.desiredCameraState) + "/" + String.valueOf(newPoi.changeSoundSetting) + "/" + String.valueOf(newPoi.desiredSoundSetting)); + + return newAction; + } + + // Processes title tags in the feed. + private static String readTag(XmlPullParser parser, String tagName) throws IOException, XmlPullParserException + { + parser.require(XmlPullParser.START_TAG, null, tagName); + String title = readText(parser); + parser.require(XmlPullParser.END_TAG, null, tagName); + return title; + } + + // For the tags title and summary, extracts their text values. + private static String readText(XmlPullParser parser) throws IOException, XmlPullParserException + { + String result = ""; + if (parser.next() == XmlPullParser.TEXT) + { + result = parser.getText(); + parser.nextTag(); + } + return result; + } + + private static void skip(XmlPullParser parser) throws XmlPullParserException, IOException + { + if (parser.getEventType() != XmlPullParser.START_TAG) + { + throw new IllegalStateException(); + } + int depth = 1; + while (depth != 0) + { + switch (parser.next()) + { + case XmlPullParser.END_TAG: + depth--; + break; + case XmlPullParser.START_TAG: + depth++; + break; + } + } + } + + public static boolean migrateFilesFromRootToFolder(String oldPath, String newPath) + { + File oldDir = new File(oldPath); + if(oldDir.isDirectory()) + { + File newDir = new File(newPath); + + File[] files = oldDir.listFiles(); + for(File file : files) + { + if(file.getName().startsWith("Automation") && file.isFile()) + file.renameTo(new File(newDir, file.getName())); + } + + return true; + } + + return false; + } +} \ No newline at end of file diff --git a/app/src/main/java/com/jens/automation2/location/CellLocationChangedReceiver.java b/app/src/main/java/com/jens/automation2/location/CellLocationChangedReceiver.java new file mode 100644 index 0000000..bdd85e9 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/location/CellLocationChangedReceiver.java @@ -0,0 +1,407 @@ +package com.jens.automation2.location; + +import android.content.Context; +import android.location.Criteria; +import android.location.Location; +import android.location.LocationListener; +import android.location.LocationManager; +import android.os.Build; +import android.os.Bundle; +import android.os.Handler; +import android.os.Message; +import android.telephony.CellLocation; +import android.telephony.PhoneStateListener; +import android.telephony.TelephonyManager; +import android.util.Log; +import android.widget.Toast; + +import com.jens.automation2.Action; +import com.jens.automation2.ActivityPermissions; +import com.jens.automation2.AutomationService; +import com.jens.automation2.Miscellaneous; +import com.jens.automation2.PointOfInterest; +import com.jens.automation2.R; +import com.jens.automation2.Rule; +import com.jens.automation2.Settings; +import com.jens.automation2.receivers.ConnectivityReceiver; + +import java.util.Date; + +public class CellLocationChangedReceiver extends PhoneStateListener +{ + private LocationManager myLocationManager; + private Location currentLocation; + public MyLocationListener myLocationListener = new MyLocationListener(); + public Boolean locationListenerArmed = false; + public Date lastCellLocationUpdate; + protected static boolean followUpdate = true; + protected static TimeoutHandler timeoutHandler = null; + protected static boolean timeoutHandlerActive = false; + protected static boolean cellLocationListenerActive = false; + protected static CellLocationChangedReceiver instance; + protected static TelephonyManager telephonyManager; + + public static boolean isCellLocationListenerActive() + { + return cellLocationListenerActive; + } + + protected static CellLocationChangedReceiver getInstance() + { + if(instance == null) + instance = new CellLocationChangedReceiver(); + + return instance; + } + + @Override + public void onCellLocationChanged(CellLocation location) + { + super.onCellLocationChanged(location); + + if(Settings.useAccelerometerForPositioning) + SensorActivity.startAccelerometerTimer(); + + if(followUpdate) + { + Date currentDate = new Date(); + + Miscellaneous.logEvent("i", "CellLocation", String.format(Miscellaneous.getAnyContext().getResources().getString(R.string.cellMastChanged), location.toString()), 3); + + if(Settings.useAccelerometerForPositioning) //and last cell mast change longer than x minutes in the past + { + PointOfInterest possiblyActivePoi = PointOfInterest.getActivePoi(); + if( possiblyActivePoi != null ) //if any poi is active + { + // Did the last activated rule activate wifi? Then we don't need accelerometer, we'll use wifiReceiver + try + { + for(Action action : Rule.getLastActivatedRule().getActionSet()) + { + if(action.getAction() == Action.Action_Enum.turnWifiOn) + { + // we will be using wifiReceiver, deactivate AccelerometerTimer if applicable + SensorActivity.stopAccelerometerTimer(); + } + } + } + catch(NullPointerException ne) + { + // Nothing to do, there is no last activated rule. Wifi hasn't been activated so we don't + // deactive accelerometer receiver. + } + } + else + { + if(lastCellLocationUpdate == null) + SensorActivity.startAccelerometerTimer(); + else + { + long timeSinceLastUpdate = currentDate.getTime() - lastCellLocationUpdate.getTime(); //in milliseconds + if(timeSinceLastUpdate > Settings.useAccelerometerAfterIdleTime*60*1000) + { + SensorActivity.startAccelerometerTimer(); + } + else + { + //reset timer + SensorActivity.resetAccelerometerTimer(); + } + } + } + } + lastCellLocationUpdate = currentDate; + + myLocationManager = (LocationManager) AutomationService.getInstance().getSystemService(Context.LOCATION_SERVICE); + currentLocation = getLocation("coarse"); + AutomationService.getInstance().getLocationProvider().setCurrentLocation(currentLocation, false); + } + else + { + Miscellaneous.logEvent("i", "CellLocation", "Cell mast changed, but only initial update, ignoring this one.", 4); + followUpdate = true; //for next run + } + } + + + public Location getLocation(String accuracy) + { + Criteria crit = new Criteria(); + + String myProviderName; + + // If privacy mode or no data connection available + if(Settings.privacyLocationing | !ConnectivityReceiver.isDataConnectionAvailable(AutomationService.getInstance())) + { + Miscellaneous.logEvent("i", "CellLocation", Miscellaneous.getAnyContext().getResources().getString(R.string.enforcingGps), 4); + myProviderName = LocationManager.GPS_PROVIDER; + } + else + { + Miscellaneous.logEvent("i", "CellLocation", Miscellaneous.getAnyContext().getResources().getString(R.string.notEnforcingGps), 4); + + if(accuracy.equals("coarse")) + { + crit.setPowerRequirement(Criteria.POWER_LOW); + crit.setAltitudeRequired(false); + crit.setSpeedRequired(false); + crit.setBearingRequired(false); + crit.setCostAllowed(false); + crit.setAccuracy(Criteria.ACCURACY_COARSE); + } + else //equals "fine" + { + crit.setPowerRequirement(Criteria.POWER_LOW); + crit.setAltitudeRequired(false); + crit.setSpeedRequired(false); + crit.setBearingRequired(false); + //crit.setCostAllowed(false); + crit.setAccuracy(Criteria.ACCURACY_FINE); + } + + myProviderName = myLocationManager.getBestProvider(crit, true); + } + + if(myProviderName == null) + { + Toast.makeText(Miscellaneous.getAnyContext(), "No suitable location provider could be used.", Toast.LENGTH_LONG).show(); + return null; + } + else + { + if(!myLocationManager.isProviderEnabled(myProviderName)) + { + if(myProviderName.equals(LocationManager.NETWORK_PROVIDER)) + myProviderName = LocationManager.GPS_PROVIDER; + } + + if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) + myProviderName = LocationManager.GPS_PROVIDER; + + // Arm location updates + if(!locationListenerArmed) + startLocationListener(myProviderName); + + try + { + return myLocationManager.getLastKnownLocation(myProviderName); + } + catch(NullPointerException e) + { + Toast.makeText(Miscellaneous.getAnyContext(), "No last known location. Aborting...", Toast.LENGTH_LONG).show(); + return null; + } + } + } + + private void startLocationListener(String providerToBeUsed) + { + Miscellaneous.logEvent("i", "LocationListener", "Arming location listener, Provider " + providerToBeUsed, 4); + myLocationManager.requestLocationUpdates(providerToBeUsed, Settings.minimumTimeBetweenUpdate, Settings.minimumDistanceChangeForNetworkUpdate, myLocationListener); + locationListenerArmed = true; + + // (re)set timeout + if(timeoutHandlerActive) + stopTimeOutHandler(); + startTimeOutHandler(); + } + private void stopLocationListener() + { + Miscellaneous.logEvent("i", "LocationListener", "Disarming location listener.", 4); + myLocationManager.removeUpdates(myLocationListener); + locationListenerArmed = false; + + if(timeoutHandlerActive) + stopTimeOutHandler(); + } + + public Location getCurrentLocation() + { + return currentLocation; + } + + + public void setCurrentLocation(Location currentLocation) + { + this.currentLocation = currentLocation; + } + + + public class MyLocationListener implements LocationListener + { + @Override + public void onLocationChanged(Location up2DateLocation) + { + if(timeoutHandlerActive) + { + stopTimeOutHandler(); + } + + setCurrentLocation(up2DateLocation); + AutomationService.getInstance().getLocationProvider().setCurrentLocation(up2DateLocation, false); + // This is relevant if the program just started, knows where it is, but hasn't reached any POI. + // The below PointOfInterest.positionUpdate() will not update the notification in that case. +// if(!currentLocation.equals(up2DateLocation)) +// parentLocationProvider.parentService.updateNotification(); + + if(up2DateLocation.getAccuracy() < Settings.satisfactoryAccuracyNetwork) + { + myLocationManager.removeUpdates(this); + locationListenerArmed = false; + Miscellaneous.logEvent("i", "LocationListener", "Disarmed location listener, accuracy reached", 4); + } + +// Miscellaneous.logEvent("i", "LocationListener", "Giving update to POI class"); +// PointOfInterest.positionUpdate(up2DateLocation, parentLocationProvider.parentService); + } + + @Override + public void onProviderDisabled(String provider) + { + // TODO Auto-generated method stub + + } + + @Override + public void onProviderEnabled(String provider) + { + // TODO Auto-generated method stub + + } + + @Override + public void onStatusChanged(String provider, int status, Bundle extras) + { + // TODO Auto-generated method stub + + } + } + + class TimeoutHandler extends Handler + { + @Override + public void handleMessage(Message msg) + { + super.handleMessage(msg); + + if(msg.what == 1) + { + Context context = Miscellaneous.getAnyContext(); + Miscellaneous.logEvent("i", context.getResources().getString(R.string.gpsMeasurement), context.getResources().getString(R.string.gpsMeasurementTimeout), 4); + stopLocationListener(); + } + } + } + + private void startTimeOutHandler() + { + if(timeoutHandler == null) + timeoutHandler = new TimeoutHandler(); + + Message message = new Message(); + message.what = 1; + timeoutHandler.sendMessageDelayed(message, Settings.gpsTimeout * 1000); + timeoutHandlerActive = true; + } + private void stopTimeOutHandler() + { + if(timeoutHandler == null) + timeoutHandler = new TimeoutHandler(); + + timeoutHandler.removeMessages(1); + timeoutHandlerActive = false; + } + + public static void startCellLocationChangedReceiver() + { + if(telephonyManager == null) + telephonyManager = (TelephonyManager) AutomationService.getInstance().getSystemService(Context.TELEPHONY_SERVICE); + + try + { + if(!cellLocationListenerActive) + { + if(!ConnectivityReceiver.isAirplaneMode(AutomationService.getInstance())) + { + if(WifiBroadcastReceiver.mayCellLocationReceiverBeActivated()) + { + // if(!ConnectivityReceiver.isDataConnectionAvailable(parentService)) + // { + telephonyManager.listen(getInstance(), PhoneStateListener.LISTEN_CELL_LOCATION); + cellLocationListenerActive = true; + Miscellaneous.logEvent("i", "cellReceiver", "Starting cellLocationListener", 4); + + SensorActivity.stopAccelerometerTimer(); + SensorActivity.stopAccelerometerReceiver(); + // this.stopWifiReceiver(); + + /* + We could now set a timer when we could activate a location check. + If that fires we need to check if maybe another location check has been performed. + */ + + if(!LocationProvider.speedTimerActive) + LocationProvider.startSpeedTimer(LocationProvider.getEtaAtNextPoi()); + // } + // else + // Miscellaneous.logEvent("i", "cellReceiver", "Not starting cellLocationListener because we have no data connection.", 4); + } + else + Miscellaneous.logEvent("w", "cellReceiver", "Wanted to activate CellLocationChangedReceiver, but Wifi-Receiver says not to.", 4); + } + else + Miscellaneous.logEvent("i", "cellReceiver", "Not starting cellLocationListener because Airplane mode is active.", 4); + } + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", "Wifi Listener", "Error starting cellLocationListener: " + Log.getStackTraceString(ex), 3); + } + } + + public static void stopCellLocationChangedReceiver() + { + try + { + if(cellLocationListenerActive) + { + Miscellaneous.logEvent("i", "cellReceiver", "Stopping cellLocationListener", 4); + + getInstance().stopTimeOutHandler(); + getInstance().stopLocationListener(); + + if(LocationProvider.speedTimerActive) + LocationProvider.stopSpeedTimer(); + + telephonyManager.listen(instance, PhoneStateListener.LISTEN_NONE); + cellLocationListenerActive = false; + + // May have comparison measurements active. + PointOfInterest.stopRoutine(); + } + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", "Wifi Listener", "Error stopping cellLocationListener: " + Log.getStackTraceString(ex), 3); + } + } + + public static void resetFollowUpdate() + { + followUpdate = false; + } + + public static boolean haveAllPermission() + { + return ActivityPermissions.havePermission("android.permission.ACCESS_FINE_LOCATION", Miscellaneous.getAnyContext()) + && + ActivityPermissions.havePermission("android.permission.ACCESS_COARSE_LOCATION", Miscellaneous.getAnyContext()) + && + ActivityPermissions.havePermission("android.permission.ACCESS_NETWORK_STATE", Miscellaneous.getAnyContext()) + && + ActivityPermissions.havePermission("android.permission.INTERNET", Miscellaneous.getAnyContext()) + && + ActivityPermissions.havePermission("android.permission.ACCESS_WIFI_STATE", Miscellaneous.getAnyContext()); + } +} + diff --git a/app/src/main/java/com/jens/automation2/location/GeofenceBroadcastReceiver.java b/app/src/main/java/com/jens/automation2/location/GeofenceBroadcastReceiver.java new file mode 100644 index 0000000..d2c78e6 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/location/GeofenceBroadcastReceiver.java @@ -0,0 +1,54 @@ +package com.jens.automation2.location; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.util.Log; + +import com.google.android.gms.location.Geofence; +import com.google.android.gms.location.GeofencingEvent; +import com.jens.automation2.Miscellaneous; + +import java.util.List; + +import static eu.chainfire.libsuperuser.Debug.TAG; + +public class GeofenceBroadcastReceiver extends BroadcastReceiver +{ + @Override + public void onReceive(Context context, Intent intent) + { + GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent(intent); + if (geofencingEvent.hasError()) + { +// Miscellaneous.logEvent("i", "Geofence", geofenceTransitionDetails, 2); +// String errorMessage = GeofenceStatusCodes.getErrorString(geofencingEvent.getErrorCode()); + Log.e(TAG, "Geofence error"); + return; + } + + // Get the transition type. + int geofenceTransition = geofencingEvent.getGeofenceTransition(); + + // Test that the reported transition was of interest. + if (geofenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER || geofenceTransition == Geofence.GEOFENCE_TRANSITION_EXIT) + { + // Get the geofences that were triggered. A single event can trigger + // multiple geofences. + List triggeringGeofences = geofencingEvent.getTriggeringGeofences(); + + // Get the transition details as a String. + String geofenceTransitionDetails = "something happened";//getGeofenceTransitionDetails(this, geofenceTransition, triggeringGeofences); + + // Send notification and log the transition details. + Miscellaneous.logEvent("i", "Geofence", geofenceTransitionDetails, 2); + Log.i(TAG, geofenceTransitionDetails); + } + else + { + // Log the error. +// Log.e(TAG, getString(R.string.geofence_transition_invalid_type, geofenceTransition)); + Log.e("Geofence", String.valueOf(geofenceTransition)); + } + } +} diff --git a/app/src/main/java/com/jens/automation2/location/GeofenceIntentService.java b/app/src/main/java/com/jens/automation2/location/GeofenceIntentService.java new file mode 100644 index 0000000..3b20edb --- /dev/null +++ b/app/src/main/java/com/jens/automation2/location/GeofenceIntentService.java @@ -0,0 +1,109 @@ +package com.jens.automation2.location; + +import android.app.IntentService; +import android.app.PendingIntent; +import android.content.Intent; + +import androidx.annotation.Nullable; + +import com.google.android.gms.common.api.GoogleApiClient; +import com.google.android.gms.location.GeofencingClient; +import com.google.android.gms.location.GeofencingRequest; +import com.google.android.gms.location.LocationServices; +import com.jens.automation2.PointOfInterest; + +import java.util.ArrayList; +import java.util.List; + +public class GeofenceIntentService extends IntentService +{ + private GeofencingClient mGeofencingClient; + protected static GoogleApiClient googleApiClient = null; + PendingIntent geofencePendingIntent; + + static GeofenceIntentService instance; + + List geoFenceList = new ArrayList<>(); + + public static GeofenceIntentService getInstance() + { + if (instance == null) + instance = new GeofenceIntentService("Automation"); + + return instance; + } + + public GeofenceIntentService(String name) + { + super(name); + } + + @Override + protected void onHandleIntent(@Nullable Intent intent) + { + + } + + @Override + public void onCreate() + { + mGeofencingClient = LocationServices.getGeofencingClient(this); + + } + + public void addFence(PointOfInterest poi) + { + com.google.android.gms.location.Geofence geofence = new com.google.android.gms.location.Geofence.Builder() + .setRequestId(poi.getName()) // Geofence ID + .setCircularRegion(poi.getLocation().getLatitude(), poi.getLocation().getLongitude(), (float) poi.getRadius()) // defining fence region + .setExpirationDuration(com.google.android.gms.location.Geofence.NEVER_EXPIRE) // expiring date + // Transition types that it should look for + .setTransitionTypes(com.google.android.gms.location.Geofence.GEOFENCE_TRANSITION_ENTER | com.google.android.gms.location.Geofence.GEOFENCE_TRANSITION_EXIT) + .build(); + + geoFenceList.add(geofence); + + GeofencingRequest request = new GeofencingRequest.Builder() + // Notification to trigger when the Geofence is created + .setInitialTrigger(GeofencingRequest.INITIAL_TRIGGER_ENTER) + .addGeofence(geofence) // add a Geofence + .build(); + + mGeofencingClient.removeGeofences(getGeofencePendingIntent()); + } + + public static void startService() + { + for (PointOfInterest poi : PointOfInterest.getPointOfInterestCollection()) + getInstance().addFence(poi); + } + + public static void stopService() + { + for (PointOfInterest poi : PointOfInterest.getPointOfInterestCollection()) + getInstance().addFence(poi); + } + + /** + * Gets a PendingIntent to send with the request to add or remove Geofences. Location Services + * issues the Intent inside this PendingIntent whenever a geofence transition occurs for the + * current list of geofences. + * + * @return A PendingIntent for the IntentService that handles geofence transitions. + */ + + private PendingIntent getGeofencePendingIntent() + { + // Reuse the PendingIntent if we already have it. + if (geofencePendingIntent != null) + { + return geofencePendingIntent; + } + Intent intent = new Intent(this, GeofenceBroadcastReceiver.class); + // We use FLAG_UPDATE_CURRENT so that we get the same pending intent back when + // calling addGeofences() and removeGeofences(). + geofencePendingIntent = PendingIntent.getBroadcast(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT); + return geofencePendingIntent; + + } +} \ No newline at end of file diff --git a/app/src/main/java/com/jens/automation2/location/LocationProvider.java b/app/src/main/java/com/jens/automation2/location/LocationProvider.java new file mode 100644 index 0000000..76ec703 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/location/LocationProvider.java @@ -0,0 +1,506 @@ +package com.jens.automation2.location; + +import android.content.Context; +import android.location.Location; +import android.location.LocationListener; +import android.location.LocationManager; +import android.os.Bundle; +import android.os.Handler; +import android.os.Message; +import android.util.Log; + +import com.jens.automation2.ActivityMainScreen; +import com.jens.automation2.AutomationService; +import com.jens.automation2.Miscellaneous; +import com.jens.automation2.PointOfInterest; +import com.jens.automation2.R; +import com.jens.automation2.Rule; +import com.jens.automation2.Settings; +import com.jens.automation2.Trigger.Trigger_Enum; +import com.jens.automation2.receivers.ConnectivityReceiver; +import com.jens.automation2.receivers.PhoneStatusListener; + +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Calendar; + +public class LocationProvider +{ + + protected static boolean passiveLocationListenerActive = false; + + protected static LocationListener passiveLocationListener; + + protected static LocationProvider locationProviderInstance = null; + + protected AutomationService parentService; + public AutomationService getParentService() + { + return parentService; + } + + protected Location currentLocation; + protected static Location currentLocationStaticCopy; + protected static double speed; + protected ArrayList locationList = new ArrayList(); + protected static Handler speedHandler = null; + protected static boolean speedTimerActive = false; + protected static Calendar etaAtNextPoi = null; + + public static Calendar getEtaAtNextPoi() + { + return etaAtNextPoi; + } + + public LocationProvider(AutomationService parent) + { + parentService = parent; + locationProviderInstance = this; + + startLocationService(); + } + + public static LocationProvider getInstance() + { + return locationProviderInstance; + } + + public Location getCurrentLocation() + { + return currentLocation; + } + public static Location getLastKnownLocation() + { + return currentLocationStaticCopy; + } + + public static double getSpeed() + { + return speed; + } + + public static void setSpeed(double speed) + { + LocationProvider.speed = speed; + + /* + Check if the last location update may be to old. + It could be that for whatever reason we didn't get a recent location, but the current speed + indicates we have moved quite a bit. + */ + + Calendar now = Calendar.getInstance(); + + float distanceToClosestPoi = PointOfInterest.getClosestPOI(getLastKnownLocation()).getLocation().distanceTo(getLastKnownLocation()); + long timeInSecondsPassedSinceLastLocationUpdate = (now.getTimeInMillis() - getLastKnownLocation().getTime()) / 1000; + + // Could be we were driving towards it instead of away, but we'll ignore that for the moment. + + long secondsRequiredForArrival = now.getTimeInMillis()/1000 / (1000 / 60 * 60); + now.add(Calendar.SECOND, (int)secondsRequiredForArrival); + + etaAtNextPoi = now; + + if(speedTimerActive) + resetSpeedTimer(etaAtNextPoi); + else + startSpeedTimer(etaAtNextPoi); + } + + public void setCurrentLocation(Location newLocation, boolean skipVerification) + { + Miscellaneous.logEvent("i", "Location", "Setting location.", 4); + + currentLocation = newLocation; + currentLocationStaticCopy = newLocation; + + Miscellaneous.logEvent("i", "LocationListener", "Giving update to POI class", 4); + PointOfInterest.positionUpdate(newLocation, parentService, false, skipVerification); + + try + { + if( + locationList.size() >= 1 + && + locationList.get(locationList.size()-1).getTime() == newLocation.getTime() + && + locationList.get(locationList.size()-1).getProvider().equals(newLocation.getProvider()) + ) + { + // This is a duplicate update, do not store it + Miscellaneous.logEvent("i", "LocationListener", "Duplicate location, ignoring.", 4); + } + else + { + Miscellaneous.logEvent("i", "Speed", "Commencing speed calculation.", 4); + // This part keeps the last two location entries to determine the current speed. + + locationList.add(newLocation); + + if(newLocation.hasSpeed()) + { + Miscellaneous.logEvent("i", "Speed", "Location has speed, taking that: " + String.valueOf(newLocation.getSpeed()) + " km/h", 4); + setSpeed(newLocation.getSpeed()); // Take the value that came with the location, that should be more precise + } + else + { + if (locationList.size() >= 2) + { + Miscellaneous.logEvent("i", "Speed", "Trying to calculate speed based on the last locations.", 4); + + double currentSpeed; + long timeDifferenceInSeconds = (Math.abs(locationList.get(locationList.size() - 2).getTime() - locationList.get(locationList.size() - 1).getTime())) / 1000; //milliseconds + if (timeDifferenceInSeconds <= Settings.speedMaximumTimeBetweenLocations * 60) + { + double distanceTraveled = locationList.get(locationList.size() - 2).distanceTo(locationList.get(locationList.size() - 1)); //results in meters + + if (timeDifferenceInSeconds == 0) + { + Miscellaneous.logEvent("w", "Speed", "No time passed since last position. Can't calculate speed here.", 4); + return; + } + + currentSpeed = distanceTraveled / timeDifferenceInSeconds * 3.6; // convert m/s --> km/h + + /* + Due to strange factors the time difference might be 0 resulting in mathematical error. + */ + if (Double.isInfinite(currentSpeed) | Double.isNaN(currentSpeed)) + Miscellaneous.logEvent("i", "Speed", "Error while calculating speed.", 4); + else + { + Miscellaneous.logEvent("i", "Speed", "Current speed: " + String.valueOf(currentSpeed) + " km/h", 2); + + setSpeed(currentSpeed); + + // execute matching rules containing speed + ArrayList ruleCandidates = Rule.findRuleCandidatesBySpeed(); + for (Rule oneRule : ruleCandidates) + { + if (oneRule.applies(this.getParentService())) + oneRule.activate(getParentService(), false); + } + } + } + else + Miscellaneous.logEvent("i", "Speed", "Last two locations are too far apart in terms of time. Cannot use them for speed calculation.", 4); + + + while (locationList.size() > 2) + { + // Remove all entries except for the last 2 + Miscellaneous.logEvent("i", "Speed", "About to delete oldest position record until only 2 left. Currently have " + String.valueOf(locationList.size()) + " records.", 4); + locationList.remove(0); + } + } + else + { + Miscellaneous.logEvent("w", "Speed", "Don't have enough values for speed calculation, yet.", 3); + } + } + } + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "Speed", "Error during speed calculation: " + Log.getStackTraceString(e), 3); + } + + AutomationService.updateNotification(); + + if(AutomationService.isMainActivityRunning(parentService)) + ActivityMainScreen.updateMainScreen(); + } + + public void startLocationService() + { +// if(Settings.useAccelerometerForPositioning && !Miscellaneous.isAndroidEmulator()) +// { +// accelerometerHandler = new AccelerometerHandler(); +// mySensorActivity = new SensorActivity(this); +// } + + // startPhoneStateListener + PhoneStatusListener.startPhoneStatusListener(parentService); // also used to mute anouncements during calls + + // startConnectivityReceiver + ConnectivityReceiver.startConnectivityReceiver(parentService); + + if(Settings.positioningEngine == 0) + { + // startCellLocationChangedReceiver + if (!ConnectivityReceiver.isAirplaneMode(this.parentService) && WifiBroadcastReceiver.mayCellLocationReceiverBeActivated() && (Rule.isAnyRuleUsing(Trigger_Enum.pointOfInterest) | Rule.isAnyRuleUsing(Trigger_Enum.speed))) + CellLocationChangedReceiver.startCellLocationChangedReceiver(); + + // startPassiveLocationListener + if(Rule.isAnyRuleUsing(Trigger_Enum.pointOfInterest) | Rule.isAnyRuleUsing(Trigger_Enum.speed)) + startPassiveLocationListener(); + } + else + { + if(Rule.isAnyRuleUsing(Trigger_Enum.pointOfInterest)) + GeofenceIntentService.startService(); + } + } + + public void stopLocationService() + { + try + { + PhoneStatusListener.stopPhoneStatusListener(parentService); + CellLocationChangedReceiver.stopCellLocationChangedReceiver(); + SensorActivity.stopAccelerometerReceiver(); + WifiBroadcastReceiver.stopWifiReceiver(); + SensorActivity.stopAccelerometerReceiver(); + stopPassiveLocationListener(); + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "cellReceiver", "Error stopping LocationReceiver: " + Log.getStackTraceString(e), 3); + } + } + + public void startPassiveLocationListener() + { + if(!passiveLocationListenerActive) + { + Miscellaneous.logEvent("i", "LocationListener", "Arming passive location listener.", 4); + LocationManager myLocationManager = (LocationManager) parentService.getSystemService(Context.LOCATION_SERVICE); + passiveLocationListener = new MyPassiveLocationListener(); + try + { + myLocationManager.requestLocationUpdates(LocationManager.PASSIVE_PROVIDER, Settings.minimumTimeBetweenUpdate, Settings.minimumDistanceChangeForNetworkUpdate, passiveLocationListener); + } + catch(SecurityException e) + {} + passiveLocationListenerActive = true; + } + } + public void stopPassiveLocationListener() + { + if(passiveLocationListenerActive) + { + Miscellaneous.logEvent("i", "LocationListener", "Disarming passive location listener.", 4); + LocationManager myLocationManager = (LocationManager) parentService.getSystemService(Context.LOCATION_SERVICE); + myLocationManager.removeUpdates(passiveLocationListener); + passiveLocationListenerActive = false; + } + } + + public class MyPassiveLocationListener implements LocationListener + { + @Override + public void onLocationChanged(Location up2DateLocation) + { + Miscellaneous.logEvent("i", "Location", "Got passive location update, provider: " + up2DateLocation.getProvider(), 3); + setCurrentLocation(up2DateLocation, true); + } + + @Override + public void onProviderDisabled(String provider) + { + // TODO Auto-generated method stub + + } + + @Override + public void onProviderEnabled(String provider) + { + // TODO Auto-generated method stub + + } + + @Override + public void onStatusChanged(String provider, int status, Bundle extras) + { + // TODO Auto-generated method stub + + } + } + + public void handleAirplaneMode(boolean state) + { + if(state) + { + Miscellaneous.logEvent("i", "Airplane mode", "CellLocationChangedReceiver will be deactivated due to Airplane mode.", 2); + CellLocationChangedReceiver.stopCellLocationChangedReceiver(); + } + else + { + Miscellaneous.logEvent("i", "Airplane mode", "CellLocationChangedReceiver will be activated due to end of Airplane mode.", 2); + CellLocationChangedReceiver.startCellLocationChangedReceiver(); + } + } + + public void handleRoaming(Boolean roaming) + { + if(roaming) + { + Miscellaneous.logEvent("i", "Roaming", "We're on roaming.", 4); + if(CellLocationChangedReceiver.isCellLocationListenerActive()) + { + Miscellaneous.logEvent("i", "Roaming", "Disabling CellLocationChangedReceiver because we're on roaming.", 3); + CellLocationChangedReceiver.stopCellLocationChangedReceiver(); + } + } + else + { + Miscellaneous.logEvent("i", "Roaming", "We're not on roaming.", 4); + if(!CellLocationChangedReceiver.isCellLocationListenerActive()) + { + Miscellaneous.logEvent("i", "Roaming", "Enabling CellLocationChangedReceiver because we're not on roaming.", 3); + CellLocationChangedReceiver.startCellLocationChangedReceiver(); + } + } + } + + public void applySettingsAndRules() + { + /* + * This method's purpose is to check settings and rules and determine + * if changes in them require monitors to be started or stopped. + * It takes care only of those which are more expensive. + */ + + // TextToSpeech is handled in AutomationService class + + Miscellaneous.logEvent("i", "LocationProvider", this.getParentService().getResources().getString(R.string.applyingSettingsAndRules), 3); + + // *********** SETTING CHANGES *********** + if(Settings.useWifiForPositioning && !WifiBroadcastReceiver.isWifiListenerActive()) + { + Miscellaneous.logEvent("i", "LocationProvider", "Starting WifiReceiver because settings now allow to.", 4); + WifiBroadcastReceiver.startWifiReceiver(this); + } + else if(!Settings.useWifiForPositioning && WifiBroadcastReceiver.isWifiListenerActive()) + { + Miscellaneous.logEvent("i", "LocationProvider", "Shutting down WifiReceiver because settings forbid to.", 4); + WifiBroadcastReceiver.stopWifiReceiver(); + } + + if(Settings.useAccelerometerForPositioning && !SensorActivity.isAccelerometerReceiverActive()) + { + Miscellaneous.logEvent("i", "LocationProvider", "Starting accelerometerReceiver because settings now allow to.", 4); + SensorActivity.startAccelerometerReceiver(); + } + else if(!Settings.useAccelerometerForPositioning && SensorActivity.isAccelerometerReceiverActive()) + { + Miscellaneous.logEvent("i", "LocationProvider", "Shutting down accelerometerReceiver because settings forbid to.", 4); + SensorActivity.stopAccelerometerReceiver(); + } + + // *********** RULE CHANGES *********** + if(!CellLocationChangedReceiver.isCellLocationListenerActive() && (Rule.isAnyRuleUsing(Trigger_Enum.pointOfInterest) | Rule.isAnyRuleUsing(Trigger_Enum.speed))) + { + Miscellaneous.logEvent("i", "LocationProvider", "Starting NoiseListener CellLocationChangedReceiver because used in a new/changed rule.", 4); + if(CellLocationChangedReceiver.haveAllPermission()) + CellLocationChangedReceiver.startCellLocationChangedReceiver(); + } + else + { + Miscellaneous.logEvent("i", "LocationProvider", "Shutting down CellLocationChangedReceiver because not used in any rule.", 4); + CellLocationChangedReceiver.stopCellLocationChangedReceiver(); + } + + AutomationService.updateNotification(); + } + + public static void startSpeedTimer(Calendar timeOfForcedLocationCheck) + { + if(!speedTimerActive) + { + if(timeOfForcedLocationCheck == null) + { + Miscellaneous.logEvent("i", "SpeedTimer", "Have no value for speed timer. Using 5 minutes in the future.", 4); + timeOfForcedLocationCheck = Calendar.getInstance(); + timeOfForcedLocationCheck.add(Calendar.MINUTE, 5); + } + + Calendar calendar = Calendar.getInstance(); + SimpleDateFormat sdf = new SimpleDateFormat(Settings.dateFormat); + + Miscellaneous.logEvent("i", "SpeedTimer", "Starting SpeedTimer. Next forced location check would be at " + sdf.format(calendar.getTime()), 4); + + Message msg = new Message(); + msg.what = 1; + + if(speedHandler == null) + speedHandler = new SpeedHandler(); + + speedHandler.sendMessageAtTime(msg, timeOfForcedLocationCheck.getTimeInMillis()); +// speedHandler.sendMessageDelayed(msg, delayTime); + speedTimerActive = true; + } + } + + public static void stopSpeedTimer() + { + if(speedTimerActive) + { + Miscellaneous.logEvent("i", "SpeedTimer", "Stopping SpeedTimer.", 4); + +// Message msg = new Message(); +// msg.what = 0; + + if(speedHandler == null) + speedHandler = new SpeedHandler(); + else + speedHandler.removeMessages(1); + + speedTimerActive = false; + } + } + + + public static void resetSpeedTimer(Calendar timeOfForcedLocationCheck) + { + if(speedTimerActive) + { + if(timeOfForcedLocationCheck == null) + { + Miscellaneous.logEvent("i", "SpeedTimer", "Have no value for speed timer. Using 5 minutes in the future.", 4); + timeOfForcedLocationCheck = Calendar.getInstance(); + timeOfForcedLocationCheck.add(Calendar.MINUTE, 5); + } + + Calendar calendar = Calendar.getInstance(); + SimpleDateFormat sdf = new SimpleDateFormat(Settings.dateFormat); + + Miscellaneous.logEvent("i", "SpeedTimer", "Resetting SpeedTimer. Next forced location check would be at " + sdf.format(calendar.getTime()), 5); + speedHandler.removeMessages(1); + + Message msg = new Message(); + msg.what = 1; + speedHandler.sendMessageAtTime(msg, timeOfForcedLocationCheck.getTimeInMillis()); +// speedHandler.sendMessageDelayed(msg, delayTime); + speedTimerActive = true; + } + else + startSpeedTimer(timeOfForcedLocationCheck); + } + + static class SpeedHandler extends Handler + { + @Override + public void handleMessage(Message msg) + { + super.handleMessage(msg); + + if(msg.what == 1) + { + // time is up, no cell location updates since x minutes, start accelerometer + String text = "Timer triggered. Based on the last location and speed we may be at a POI. Forcing location update in case CellLocationChangedReceiver didn\'t fire."; +// Miscellaneous.logEvent("i", "AccelerometerHandler", text, 5); +// CellLocationChangedReceiver.stopCellLocationChangedReceiver(); +// startAccelerometerReceiver(); + Location currentLocation = CellLocationChangedReceiver.getInstance().getLocation("coarse"); + AutomationService.getInstance().getLocationProvider().setCurrentLocation(currentLocation, false); + } + /*else if(msg.what == 0) + { + String text = "Abort command received, deactivating SpeedReceiver"; + Miscellaneous.logEvent("i", "SpeedHandler", text, 4); + stopAccelerometerReceiver(); + }*/ + } + } +} \ No newline at end of file diff --git a/app/src/main/java/com/jens/automation2/location/SensorActivity.java b/app/src/main/java/com/jens/automation2/location/SensorActivity.java new file mode 100644 index 0000000..9a06a09 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/location/SensorActivity.java @@ -0,0 +1,220 @@ +package com.jens.automation2.location; + + +import android.hardware.Sensor; +import android.hardware.SensorEvent; +import android.hardware.SensorEventListener; +import android.hardware.SensorManager; +import android.os.Handler; +import android.os.Message; +import android.util.Log; + +import com.jens.automation2.AutomationService; +import com.jens.automation2.Miscellaneous; +import com.jens.automation2.Settings; + +public class SensorActivity implements SensorEventListener +{ + protected static SensorActivity instance; + private final SensorManager mSensorManager; + private final Sensor mAccelerometer; + public LocationProvider parentLocationProvider; + public static boolean mInitialized = false; + public static float lastX, lastY, lastZ, deltaX, deltaY, deltaZ; + protected static Handler accelerometerHandler = null; + protected static boolean accelerometerReceiverActive = false; + protected static boolean accelerometerTimerActive = false; + + public static boolean isAccelerometerReceiverActive() + { + return accelerometerReceiverActive; + } + + public static boolean isAccelerometerTimerActive() + { + return accelerometerTimerActive; + } + + public static SensorActivity getInstance() + { + if(instance == null) + instance = new SensorActivity(AutomationService.getInstance().getLocationProvider()); + + return instance; + } + + public SensorActivity(LocationProvider parent) + { + this.parentLocationProvider = parent; + mSensorManager = (SensorManager)parentLocationProvider.parentService.getSystemService(parentLocationProvider.parentService.SENSOR_SERVICE); + mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER); + } + + protected void start() + { + mSensorManager.registerListener(this, mAccelerometer, SensorManager.SENSOR_DELAY_NORMAL); + } + + protected void stop() + { + mSensorManager.unregisterListener(this); + } + + public void onAccuracyChanged(Sensor sensor, int accuracy) + { + } + + public void onSensorChanged(SensorEvent event) + { + // Device has been moved + + float x = event.values[0]; + float y = event.values[1]; + float z = event.values[2]; + + if(mInitialized) + { + deltaX = Math.abs(lastX-x); + deltaY = Math.abs(lastY-y); + deltaZ = Math.abs(lastZ-z); + //Wenn das jetzt einen gewissen Grenzwert übersteigt, müßten wir den CellListener wieder aktivieren + if(deltaX > Settings.accelerometerMovementThreshold | deltaY > Settings.accelerometerMovementThreshold | deltaZ > Settings.accelerometerMovementThreshold) + { + String text = "Device has been moved. " + String.valueOf(deltaX)+" / "+String.valueOf(deltaY)+" / "+String.valueOf(deltaZ); + Miscellaneous.logEvent("i", "Accelerometer", text, 5); + CellLocationChangedReceiver.resetFollowUpdate(); + CellLocationChangedReceiver.startCellLocationChangedReceiver(); + } + } + else + { + lastX = x; + lastY = y; + lastZ = z; + mInitialized = true; + } + } + + protected static void startAccelerometerReceiver() + { + if(Settings.useAccelerometerForPositioning && !Miscellaneous.isAndroidEmulator()) + { + if(!accelerometerReceiverActive) + { + try + { + getInstance().start(); + accelerometerReceiverActive = true; + Miscellaneous.logEvent("i", "AccelerometerReceiver", "Starting AccelerometerReceiver", 4); + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", "AccelerometerReceiver", "Error starting AccelerometerReceiver: " + Log.getStackTraceString(ex), 3); + } + } + } + } + protected static void stopAccelerometerReceiver() + { + if(Settings.useAccelerometerForPositioning && !Miscellaneous.isAndroidEmulator() && accelerometerReceiverActive) + { + try + { + getInstance().stop(); + accelerometerReceiverActive = false; + Miscellaneous.logEvent("i", "AccelerometerReceiver", "Stopping AccelerometerReceiver", 4); + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", "AccelerometerReceiver", "Error stopping AccelerometerReceiver: " + Log.getStackTraceString(ex), 3); + } + } + } + + public static void startAccelerometerTimer() + { + if(Settings.useAccelerometerForPositioning && !Miscellaneous.isAndroidEmulator()) + { + if(!accelerometerTimerActive) + { + Miscellaneous.logEvent("i", "AccelerometerTimer", "Starting AccelerometerTimer", 4); + + long delayTime = Settings.useAccelerometerAfterIdleTime * 60 * 1000; + + Message msg = new Message(); + msg.what = 1; + + if(accelerometerHandler == null) + accelerometerHandler = new AccelerometerHandler(); + + accelerometerHandler.sendMessageDelayed(msg, delayTime); + accelerometerTimerActive = true; + } + } + /* + * else + * reset timer + */ + } + public static void stopAccelerometerTimer() + { + if(accelerometerTimerActive) + { + Miscellaneous.logEvent("i", "AccelerometerTimer", "Stopping AccelerometerTimer", 4); + +// Message msg = new Message(); +// msg.what = 0; + + if(accelerometerHandler == null) + accelerometerHandler = new AccelerometerHandler(); + else + accelerometerHandler.removeMessages(1); + +// accelerometerHandler.sendMessageDelayed(msg, 0); + accelerometerTimerActive = false; + } + } + + + public static void resetAccelerometerTimer() + { + if(accelerometerTimerActive) + { + Miscellaneous.logEvent("i", "AccelerometerTimer", "Resetting AccelerometerTimer", 5); + accelerometerHandler.removeMessages(1); + + long delayTime = Settings.useAccelerometerAfterIdleTime * 60 * 1000; +// Toast.makeText(parentService, "Sending message, delayed for " + String.valueOf(delayTime), Toast.LENGTH_LONG).show(); + + Message msg = new Message(); + msg.what = 1; + accelerometerHandler.sendMessageDelayed(msg, delayTime); + accelerometerTimerActive = true; + } + } + + static class AccelerometerHandler extends Handler + { + @Override + public void handleMessage(Message msg) + { + super.handleMessage(msg); + + if(msg.what == 1) + { + // time is up, no cell location updates since x minutes, start accelerometer + String text = String.valueOf(Settings.useAccelerometerAfterIdleTime) + " minutes passed"; + Miscellaneous.logEvent("i", "AccelerometerHandler", text, 5); + CellLocationChangedReceiver.stopCellLocationChangedReceiver(); + startAccelerometerReceiver(); + } + else if(msg.what == 0) + { + String text = "Abort command received, deactivating accelerometerReceiver"; + Miscellaneous.logEvent("i", "AccelerometerHandler", text, 4); + stopAccelerometerReceiver(); + } + } + + } +} diff --git a/app/src/main/java/com/jens/automation2/location/WifiBroadcastReceiver.java b/app/src/main/java/com/jens/automation2/location/WifiBroadcastReceiver.java new file mode 100644 index 0000000..54f8a2f --- /dev/null +++ b/app/src/main/java/com/jens/automation2/location/WifiBroadcastReceiver.java @@ -0,0 +1,229 @@ +package com.jens.automation2.location; + + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.net.ConnectivityManager; +import android.net.NetworkInfo; +import android.net.wifi.WifiManager; +import android.util.Log; + +import com.jens.automation2.Miscellaneous; +import com.jens.automation2.PointOfInterest; +import com.jens.automation2.R; +import com.jens.automation2.Rule; +import com.jens.automation2.Settings; + +import java.util.ArrayList; + +public class WifiBroadcastReceiver extends BroadcastReceiver +{ + public static LocationProvider parentLocationProvider; + public static Boolean wasConnected = false; + protected static String lastWifiSsid = ""; + public static boolean lastConnectedState = false; + protected static boolean mayCellLocationChangedReceiverBeActivatedFromWifiPointOfWifi = true; + protected static WifiBroadcastReceiver wifiBrInstance; + protected static IntentFilter wifiListenerIntentFilter; + protected static boolean wifiListenerActive=false; + + + + public static String getLastWifiSsid() + { + return lastWifiSsid; + } + + public static void setLastWifiSsid(String newWifiSsid) + { + if(newWifiSsid.startsWith("\"") && newWifiSsid.endsWith("\"")) + newWifiSsid = newWifiSsid.substring(1, newWifiSsid.length()-1); + + WifiBroadcastReceiver.lastWifiSsid = newWifiSsid; + } + + public static boolean isWifiListenerActive() + { + return wifiListenerActive; + } + + public static boolean mayCellLocationReceiverBeActivated() + { + return mayCellLocationChangedReceiverBeActivatedFromWifiPointOfWifi; + } + + @Override + public void onReceive(Context context, Intent intent) + { + try + { + // int state = -1; + NetworkInfo myWifi = null; + + // if(intent.getAction().equals(WifiManager.RSSI_CHANGED_ACTION)) //gefeuert bei Verbindung + // { + // Miscellaneous.logEvent("i", "WifiReceiver", "RSSI_CHANGED_ACTION: " + String.valueOf(intent.getIntExtra(WifiManager.RSSI_CHANGED_ACTION, -1))); + // } + // else + if(intent.getAction().equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) //gefeuert bei Trennung + { + // state = intent.getIntExtra(WifiManager.NETWORK_STATE_CHANGED_ACTION, -1); + // Miscellaneous.logEvent("i", "WifiReceiver", "NETWORK_STATE_CHANGED_ACTION: " + String.valueOf(state)); + myWifi = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO); + } + + + WifiManager myWifiManager = (WifiManager)context.getSystemService(Context.WIFI_SERVICE); + // ConnectivityManager connManager = (ConnectivityManager)context.getSystemService(context.CONNECTIVITY_SERVICE); + // myWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI); + // myWifi = state + // WifiInfo wifiInfo = myWifiManager.getConnectionInfo(); + + // SupplicantState supState = wifiInfo.getSupplicantState(); + + if(intent.getAction().equals(WifiManager.RSSI_CHANGED_ACTION)) // fired upon connection + { + String ssid = myWifiManager.getConnectionInfo().getSSID(); + setLastWifiSsid(ssid); + Miscellaneous.logEvent("i", "WifiReceiver", String.format(context.getResources().getString(R.string.connectedToWifi), getLastWifiSsid()), 2); + wasConnected = true; + lastConnectedState = true; + + if(Settings.useWifiForPositioning && PointOfInterest.reachedPoiWithActivateWifiRule()) // Poi has wifi + { + Miscellaneous.logEvent("i", "WifiReceiver", context.getResources().getString(R.string.poiHasWifiStoppingCellLocationListener), 2); + mayCellLocationChangedReceiverBeActivatedFromWifiPointOfWifi = false; + CellLocationChangedReceiver.stopCellLocationChangedReceiver(); + } + else + { + if(!PointOfInterest.reachedPoiWithActivateWifiRule()) // Poi has no wifi + Miscellaneous.logEvent("i", "WifiReceiver", context.getResources().getString(R.string.poiHasNoWifiNotStoppingCellLocationListener), 2); + } + + findRules(parentLocationProvider); + } + else if(myWifi.isConnectedOrConnecting()) // first time connect from wifi-listener-perspective + { + wasConnected = true; + Miscellaneous.logEvent("i", "WifiReceiver", "WifiReceiver just activated. Wifi already connected. Stopping CellLocationReceiver", 3); + mayCellLocationChangedReceiverBeActivatedFromWifiPointOfWifi = false; + CellLocationChangedReceiver.stopCellLocationChangedReceiver(); + SensorActivity.stopAccelerometerTimer(); + String ssid = myWifiManager.getConnectionInfo().getSSID(); + setLastWifiSsid(ssid); + lastConnectedState = true; + findRules(parentLocationProvider); + } + else if(!myWifi.isConnectedOrConnecting()) // really disconnected? because sometimes also fires on connect + { + if(wasConnected) // wir könnten einfach noch nicht daheim sein + { + try + { + wasConnected = false; + Miscellaneous.logEvent("i", "WifiReceiver", String.format(context.getResources().getString(R.string.disconnectedFromWifi), getLastWifiSsid()) + " Switching to CellLocationChangedReceiver.", 3); + mayCellLocationChangedReceiverBeActivatedFromWifiPointOfWifi = true; + CellLocationChangedReceiver.startCellLocationChangedReceiver(); + lastConnectedState = false; + findRules(parentLocationProvider); + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "WifiReceiver", "Error starting CellLocationChangedReceiver", 3); + } + } + } + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "WifiReceiver", "Error in WifiReceiver->onReceive(): " + e.getMessage(), 3); + } + } + + public static void findRules(LocationProvider parentLocationProvider) + { + ArrayList ruleCandidates = Rule.findRuleCandidatesByWifiConnection(); + for(Rule oneRule : ruleCandidates) + { + if(oneRule.applies(parentLocationProvider.parentService)) + oneRule.activate(parentLocationProvider.parentService, false); + } + } + + public static boolean isWifiEnabled(Context context) + { + try + { + WifiManager myWifiManager = (WifiManager)context.getSystemService(Context.WIFI_SERVICE); + return myWifiManager.isWifiEnabled(); + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "WifiReceiver->isWifiEnabled()", Log.getStackTraceString(e), 3); + return false; + } + } + + public static boolean isWifiConnected(Context context) + { + try + { + ConnectivityManager connManager = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE); + NetworkInfo myWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI); + return myWifi.isConnected(); + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "WifiReceiver->isWifiConnected()", Log.getStackTraceString(e), 3); + return false; + } + } + + public static void startWifiReceiver(LocationProvider loc) + { + try + { + if(!wifiListenerActive) + { + Miscellaneous.logEvent("i", "Wifi Listener", "Starting wifiListener", 4); + if(wifiListenerIntentFilter == null) + { + wifiListenerIntentFilter = new IntentFilter(); + wifiListenerIntentFilter.addAction(WifiManager.RSSI_CHANGED_ACTION); + wifiListenerIntentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION); + } + if(wifiBrInstance == null) + { + wifiBrInstance = new WifiBroadcastReceiver(); + WifiBroadcastReceiver.parentLocationProvider = loc; + } + loc.getParentService().registerReceiver(wifiBrInstance, wifiListenerIntentFilter); + wifiListenerActive = true; + } + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", "Wifi Listener", "Error starting wifiListener: " + Log.getStackTraceString(ex), 3); + } + } + public static void stopWifiReceiver() + { + try + { + if(wifiListenerActive) + { + Miscellaneous.logEvent("i", "Wifi Listener", "Stopping wifiListener", 4); + wifiListenerActive = false; + parentLocationProvider.getParentService().unregisterReceiver(wifiBrInstance); + } + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", "Wifi Listener", "Error stopping wifiListener: " + Log.getStackTraceString(ex), 3); + } + } + +} \ No newline at end of file diff --git a/app/src/main/java/com/jens/automation2/receivers/ActivityDetectionReceiver.java b/app/src/main/java/com/jens/automation2/receivers/ActivityDetectionReceiver.java new file mode 100644 index 0000000..d4a5158 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/receivers/ActivityDetectionReceiver.java @@ -0,0 +1,400 @@ +package com.jens.automation2.receivers; + +import android.app.IntentService; +import android.app.PendingIntent; +import android.content.Intent; +import android.os.Bundle; +import android.util.Log; + +import com.google.android.gms.common.ConnectionResult; +import com.google.android.gms.common.GooglePlayServicesUtil; +import com.google.android.gms.common.api.GoogleApiClient; +import com.google.android.gms.common.api.GoogleApiClient.OnConnectionFailedListener; +import com.google.android.gms.location.ActivityRecognition; +import com.google.android.gms.location.ActivityRecognitionApi; +import com.google.android.gms.location.ActivityRecognitionResult; +import com.google.android.gms.location.DetectedActivity; +import com.jens.automation2.ActivityPermissions; +import com.jens.automation2.AutomationService; +import com.jens.automation2.Miscellaneous; +import com.jens.automation2.R; +import com.jens.automation2.Rule; +import com.jens.automation2.Settings; +import com.jens.automation2.Trigger.Trigger_Enum; + +import java.util.ArrayList; +import java.util.Date; + +// See also: http://developer.android.com/reference/com/google/android/gms/location/ActivityRecognitionClient.html +// https://www.sitepoint.com/google-play-services-location-activity-recognition/ + +public class ActivityDetectionReceiver extends IntentService implements AutomationListenerInterface, GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener +{ + protected static ActivityRecognitionApi activityRecognitionClient = null; + protected static boolean connected = false; + protected static enum LastRequestEnum { start, stop, restart }; + protected static LastRequestEnum lastRequest = null; + protected static GoogleApiClient googleApiClient = null; + protected static ActivityRecognitionResult activityDetectionLastResult = null; + protected static long lastUpdate = 0; + protected static Date currentTime; + protected static ActivityDetectionReceiver instance = null; + + protected static ActivityDetectionReceiver getInstance() + { + if(instance == null) + instance = new ActivityDetectionReceiver(); + + return instance; + } + + protected static boolean activityDetectionReceiverRunning = false; + protected static ActivityDetectionReceiver activityDetectionReceiverInstance = null; + + public static boolean isActivityDetectionReceiverRunning() + { + return activityDetectionReceiverRunning; + } + + public static ActivityRecognitionResult getActivityDetectionLastResult() + { + return activityDetectionLastResult; + } + + public static GoogleApiClient getApiClient() + { + if(googleApiClient == null) + { + googleApiClient = new GoogleApiClient.Builder(AutomationService.getInstance()) + .addConnectionCallbacks(getInstance()) + .addOnConnectionFailedListener(getInstance()) + .addApi(ActivityRecognition.API) + .build(); + } + + return googleApiClient; + } + + private static void requestUpdates() + { + long frequency = Settings.activityDetectionFrequency * 1000; + Miscellaneous.logEvent("i", "ActivityDetectionReceiver", "Requesting ActivityDetection updates with frequency " + String.valueOf(frequency) + " milliseconds.", 4); + + + ActivityRecognition.ActivityRecognitionApi.requestActivityUpdates(getApiClient(), 1000, getInstance().getActivityDetectionPendingIntent()); + } + private void reloadUpdates() + { + long frequency = Settings.activityDetectionFrequency * 1000; + Miscellaneous.logEvent("i", "ActivityDetectionReceiver", "Re-requesting ActivityDetection updates with frequency " + String.valueOf(frequency) + " milliseconds.", 4); + + activityRecognitionClient.removeActivityUpdates(getApiClient(), getInstance().getActivityDetectionPendingIntent()); + try + { + Thread.sleep(1000); + } + catch (InterruptedException e) + { + Miscellaneous.logEvent("i", "ActivityDetectionReceiver", "Error reloading updates for ActivityDetectionReceiver: " + Log.getStackTraceString(e), 5); + } + + ActivityRecognition.ActivityRecognitionApi.requestActivityUpdates(getApiClient(), frequency, getInstance().getActivityDetectionPendingIntent()); + } + + private static void stopUpdates() + { + Miscellaneous.logEvent("i", "ActivityDetectionReceiver", "Unsubscribing from ActivityDetection-updates.", 4); + + ActivityRecognition.ActivityRecognitionApi.removeActivityUpdates(getApiClient(), getInstance().getActivityDetectionPendingIntent()); +// activityRecognitionClient.removeActivityUpdates(getApiClient(), getInstance().getActivityDetectionPendingIntent()); +// activityRecognitionClient.disconnect(); + } + public static void startActivityDetectionReceiver() + { + try + { + Miscellaneous.logEvent("i", "ActivityDetectionReceiver", "Starting ActivityDetectionReceiver", 3); + + if(activityDetectionReceiverInstance == null) + activityDetectionReceiverInstance = new ActivityDetectionReceiver(); + + if(!activityDetectionReceiverRunning && Rule.isAnyRuleUsing(Trigger_Enum.activityDetection)) + { + if(isPlayServiceAvailable()) + { + /*if(activityRecognitionClient == null) + activityRecognitionClient = new ActivityRecognitionClient(Miscellaneous.getAnyContext(), activityDetectionReceiverInstance, activityDetectionReceiverInstance);*/ + + lastRequest = LastRequestEnum.start; + + if(!connected) + getApiClient().connect(); + else + requestUpdates(); + + activityDetectionReceiverRunning = true; + } + } + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", "ActivityDetectionReceiver", "Error starting ActivityDetectionReceiver: " + Log.getStackTraceString(ex), 3); + } + } + + public static void restartActivityDetectionReceiver() + { + try + { + if(!activityDetectionReceiverRunning && Rule.isAnyRuleUsing(Trigger_Enum.activityDetection)) + { + Miscellaneous.logEvent("i", "ActivityDetectionReceiver", "Restarting ActivityDetectionReceiver", 3); + + if(activityDetectionReceiverInstance == null) + activityDetectionReceiverInstance = new ActivityDetectionReceiver(); + + if(isPlayServiceAvailable()) + { +// if(activityRecognitionClient == null) +// activityRecognitionClient = new ActivityRecognitionClient(Miscellaneous.getAnyContext(), activityDetectionReceiverInstance, activityDetectionReceiverInstance); + + lastRequest = LastRequestEnum.restart; + + if(!connected) + getApiClient().connect(); + else + requestUpdates(); + } + } + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", "ActivityDetectionReceiver", "Error starting ActivityDetectionReceiver: " + Log.getStackTraceString(ex), 3); + } + + } + + public static void stopActivityDetectionReceiver() + { + try + { + if(activityDetectionReceiverRunning) + { + Miscellaneous.logEvent("i", "ActivityDetectionReceiver", "Stopping ActivityDetectionReceiver", 3); + + if(isPlayServiceAvailable()) + { + lastRequest = LastRequestEnum.stop; + + if(!connected) + getApiClient().connect(); + else + stopUpdates(); + + activityDetectionReceiverRunning = false; + } + } + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", "ActivityDetectionReceiver", "Error stopping ActivityDetectionReceiver: " + Log.getStackTraceString(ex), 3); + } + } + + public static boolean isPlayServiceAvailable() + { + if(GooglePlayServicesUtil.isGooglePlayServicesAvailable(Miscellaneous.getAnyContext()) == ConnectionResult.SUCCESS) + return true; + else + return false; + } + + + @Override + public void onConnectionFailed(ConnectionResult arg0) + { + Miscellaneous.logEvent("i", "ActivityDetectionReceiver", "Connection to Play Services failed.", 4); + if(connected && getApiClient().isConnected()) + { + connected = false; + } + } + + @Override + public void onConnected(Bundle arg0) + { + Miscellaneous.logEvent("i", "ActivityDetectionReceiver", "Connected to Play Services.", 4); + + connected = true; + + if(lastRequest == null) + { + Miscellaneous.logEvent("w", "ActivityDetectionReceiver", "Request type not specified. Start or stop listening to activity detection updates?", 4); + return; + } + + if(lastRequest.equals(LastRequestEnum.start)) + requestUpdates(); + else if(lastRequest.equals(LastRequestEnum.stop)) + stopUpdates(); + else //reload, e.g. to set a new update time + reloadUpdates(); + } + + @Override + public void onConnectionSuspended(int arg0) + { + Miscellaneous.logEvent("i", "ActivityDetectionReceiver", "Connection to Play Services suspended.", 4); +// activityRecognitionClient.disconnect(); + connected = false; + } + + public ActivityDetectionReceiver() + { + super("ActivityDetectionIntentService"); + if(instance == null) + instance = this; + } + + @Override + protected void onHandleIntent(Intent intent) + { + Miscellaneous.logEvent("i", "ActivityDetectionReceiver", "onHandleIntent(): Received some status.", 5); + + try + { + if(isActivityDetectionReceiverRunning()) + { + currentTime = new Date(); + + if(lastUpdate == 0 | currentTime.getTime() >= lastUpdate + Settings.activityDetectionFrequency * 1000 - 1000) // -1000 to include updates only marginaly below the threshold + { + lastUpdate = currentTime.getTime(); + + if(ActivityRecognitionResult.hasResult(intent)) + { + activityDetectionLastResult = ActivityRecognitionResult.extractResult(intent); + + for(DetectedActivity activity : activityDetectionLastResult.getProbableActivities()) + { + int loglevel = 3; + if(activity.getConfidence() < Settings.activityDetectionRequiredProbability) + loglevel = 4; + + Miscellaneous.logEvent("i", "ActivityDetectionReceiver", "Detected activity (probability " + String.valueOf(activity.getConfidence()) + "%): " + getDescription(activity.getType()), loglevel); + } + + /* + * Returns the list of activities that where detected with the confidence value associated with each activity. + * The activities are sorted by most probable activity first. + * The sum of the confidences of all detected activities this method returns does not have to be <= 100 + * since some activities are not mutually exclusive (for example, you can be walking while in a bus) + * and some activities are hierarchical (ON_FOOT is a generalization of WALKING and RUNNING). + */ + + ArrayList allRulesWithActivityDetection = Rule.findRuleCandidatesByActivityDetection(); + for(int i=0; i types = new ArrayList(); + + for(int type : getAllTypes()) + types.add(getDescription(type)); + + return types.toArray(new String[types.size()]); + } + + @Override + public void startListener(AutomationService automationService) + { + ActivityDetectionReceiver.startActivityDetectionReceiver(); + } + + @Override + public void stopListener(AutomationService automationService) + { + ActivityDetectionReceiver.stopActivityDetectionReceiver(); + } + + public static boolean haveAllPermission() + { + return ActivityPermissions.havePermission("com.google.android.gms.permission.ACTIVITY_RECOGNITION", Miscellaneous.getAnyContext()); + } + + @Override + public boolean isListenerRunning() + { + return ActivityDetectionReceiver.isActivityDetectionReceiverRunning(); + } + + @Override + public Trigger_Enum[] getMonitoredTrigger() + { + return new Trigger_Enum[] { Trigger_Enum.activityDetection }; + } + + private PendingIntent getActivityDetectionPendingIntent() + { + Intent intent = new Intent(AutomationService.getInstance(), ActivityDetectionReceiver.class); + PendingIntent returnValue = PendingIntent.getService(AutomationService.getInstance(), 0, intent, PendingIntent.FLAG_UPDATE_CURRENT); + return returnValue; + } +} \ No newline at end of file diff --git a/app/src/main/java/com/jens/automation2/receivers/AlarmListener.java b/app/src/main/java/com/jens/automation2/receivers/AlarmListener.java new file mode 100644 index 0000000..4c7bf10 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/receivers/AlarmListener.java @@ -0,0 +1,301 @@ +package com.jens.automation2.receivers; + +import android.app.AlarmManager; +import android.app.PendingIntent; +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; + +import com.jens.automation2.AutomationService; +import com.jens.automation2.Miscellaneous; +import com.jens.automation2.Rule; +import com.jens.automation2.Trigger; +import com.jens.automation2.Trigger.Trigger_Enum; + +import java.sql.Time; +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Calendar; +import java.util.Date; + +public class AlarmListener extends BroadcastReceiver implements AutomationListenerInterface +{ + private static AutomationService automationServiceRef; + private static AlarmManager centralAlarmManagerInstance; +// private static Intent alarmIntent; +// private static PendingIntent alarmPendingIntent; + private static boolean alarmListenerActive=false; + private static ArrayList alarmCandidates = new ArrayList(); + + private static ArrayList requestCodeList = new ArrayList(); + + public static void startAlarmListener(final AutomationService automationServiceRef) + { + AlarmListener.startAlarmListenerInternal(automationServiceRef); + } + public static void stopAlarmListener(Context context) + { + AlarmListener.stopAlarmListenerInternal(); + } + + public static boolean isAlarmListenerActive() + { + return alarmListenerActive; + } + + @Override + public void onReceive(Context context, Intent intent) + { + Miscellaneous.logEvent("i", "AlarmListener", "Alarm received", 2); + Date now = new Date(); + String timeString = String.valueOf(now.getHours()) + ":" + String.valueOf(now.getMinutes()) + ":" + String.valueOf(now.getSeconds()); + Time passTime = Time.valueOf(timeString); + + ArrayList allRulesWithNowInTimeFrame = Rule.findRuleCandidatesByTime(passTime); + for(int i=0; i allRulesWithTimeFrames = new ArrayList(); + allRulesWithTimeFrames = Rule.findRuleCandidatesByTimeFrame(); + for(Rule oneRule : allRulesWithTimeFrames) + { + for(Trigger oneTrigger : oneRule.getTriggerSet()) + { + if(oneTrigger.getTriggerType() == Trigger_Enum.timeFrame) + { + Calendar calNow, calSet; + Time setTime; + + if(oneTrigger.getTriggerParameter()) + setTime = oneTrigger.getTimeFrame().getTriggerTimeStart(); + else + setTime = oneTrigger.getTimeFrame().getTriggerTimeStop(); + + calNow = Calendar.getInstance(); + calSet = (Calendar) calNow.clone(); + calSet.set(Calendar.HOUR_OF_DAY, setTime.getHours()); + calSet.set(Calendar.MINUTE, setTime.getMinutes()); + calSet.set(Calendar.SECOND, 0); + calSet.set(Calendar.MILLISECOND, 0); + // At this point calSet would be a scheduling candidate. It's just the day the might not be right, yet. + + long milliSecondsInAWeek = 1000 * 60 * 60 * 24 * 7; + + for(int dayOfWeek : oneTrigger.getTimeFrame().getDayList()) + { + Calendar calSetWorkingCopy = (Calendar) calSet.clone(); + +// calSetWorkingCopy.set(Calendar.HOUR_OF_DAY, setTime.getHours()); +// calSetWorkingCopy.set(Calendar.MINUTE, setTime.getMinutes()); +// calSetWorkingCopy.set(Calendar.SECOND, 0); +// calSetWorkingCopy.set(Calendar.MILLISECOND, 0); + + int diff = dayOfWeek - calNow.get(Calendar.DAY_OF_WEEK); +// Log.i("AlarmManager", "Today: " + String.valueOf(calNow.get(Calendar.DAY_OF_WEEK)) + " / Sched.Day: " + String.valueOf(dayOfWeek) + " Difference to target day is: " + String.valueOf(diff)); + if(diff == 0) //if we're talking about the current day, is the time still in the future? + { + if(calSetWorkingCopy.getTime().getHours() < calNow.getTime().getHours()) + { +// Log.i("AlarmManager", "calSetWorkingCopy.getTime().getHours(" + String.valueOf(calSetWorkingCopy.getTime().getHours()) + ") < calNow.getTime().getHours(" + String.valueOf(calNow.getTime().getHours()) + ")"); + calSetWorkingCopy.add(Calendar.DAY_OF_MONTH, 7); //add a week + } + else if(calSetWorkingCopy.getTime().getHours() == calNow.getTime().getHours()) + { +// Log.i("AlarmManager", "calSetWorkingCopy.getTime().getHours() == calNow.getTime().getHours()"); + if(calSetWorkingCopy.getTime().getMinutes() <= calNow.getTime().getMinutes()) + { +// Log.i("AlarmManager", "calSetWorkingCopy.getTime().getMinutes() < calNow.getTime().getMinutes()"); + calSetWorkingCopy.add(Calendar.DAY_OF_MONTH, 7); //add a week + } + } + } + else if(diff < 0) + { +// Miscellaneous.logEvent("i", "AlarmManager", "Adding " + String.valueOf(diff+7) + " on top of " + String.valueOf(calSetWorkingCopy.get(Calendar.DAY_OF_WEEK))); + calSetWorkingCopy.add(Calendar.DAY_OF_WEEK, diff+7); // it's a past weekday, schedule for next week + } + else + { +// Miscellaneous.logEvent("i", "AlarmManager", "Adding " + String.valueOf(diff) + " on top of " + String.valueOf(calSetWorkingCopy.get(Calendar.DAY_OF_WEEK))); + calSetWorkingCopy.add(Calendar.DAY_OF_WEEK, diff); // it's a future weekday, schedule for that day + } + + i++; + i=(int)System.currentTimeMillis(); + String calSetWorkingCopyString = sdf.format(calSetWorkingCopy.getTime()) + " RequestCode: " + String.valueOf(i); +// Miscellaneous.logEvent("i", "AlarmManager", "Setting repeating alarm because of rule: " + oneRule.getName() + " beginning at " + calSetWorkingCopyString); + + alarmCandidates.add(calSetWorkingCopy.getTimeInMillis()); +// Intent alarmIntent = new Intent(automationServiceRef, AlarmListener.class); +// alarmIntent.setData(Uri.parse("myalarms://" + i)); +// PendingIntent alarmPendingIntent = PendingIntent.getBroadcast(automationServiceRef, i, alarmIntent, PendingIntent.FLAG_UPDATE_CURRENT); +// centralAlarmManagerInstance.setInexactRepeating(AlarmManager.RTC_WAKEUP, calSetWorkingCopy.getTimeInMillis(), milliSecondsInAWeek, alarmPendingIntent); +// requestCodeList.add(i); + } + } + } + } + +// // get a Calendar object with current time +// Calendar cal = Calendar.getInstance(); +// cal.add(Calendar.SECOND, 10); +// String calSetWorkingCopyString2 = sdf.format(cal.getTime()); +// Miscellaneous.logEvent("i", "AlarmManager", "Setting repeating alarm because of hardcoded test: beginning at " + calSetWorkingCopyString2); +// Intent alarmIntent2 = new Intent(automationServiceRef, AlarmListener.class); +// PendingIntent alarmPendingIntent2 = PendingIntent.getBroadcast(automationServiceRef, 0, alarmIntent2, 0); +// centralAlarmManagerInstance.setInexactRepeating(AlarmManager.RTC_WAKEUP, cal.getTimeInMillis(), 5000, alarmPendingIntent2); +// requestCodeList.add(0); + + scheduleNextAlarm(); + } + + private static void scheduleNextAlarm() + { + Long currentTime = System.currentTimeMillis(); + Long scheduleCandidate = null; + + if(alarmCandidates.size() == 0) + { + Miscellaneous.logEvent("i", "AlarmManager", "No alarms to be scheduled.", 3); + return; + } + else if(alarmCandidates.size() == 1) + { + // only one alarm, schedule that + scheduleCandidate = alarmCandidates.get(0); + } + else if(alarmCandidates.size() > 1) + { + scheduleCandidate = alarmCandidates.get(0); + + for(long alarmCandidate : alarmCandidates) + { + if(Math.abs(currentTime - alarmCandidate) < Math.abs(currentTime - scheduleCandidate)) + scheduleCandidate = alarmCandidate; + } + } + + Intent alarmIntent = new Intent(automationServiceRef, AlarmListener.class); + PendingIntent alarmPendingIntent = PendingIntent.getBroadcast(automationServiceRef, 0, alarmIntent, PendingIntent.FLAG_UPDATE_CURRENT); + centralAlarmManagerInstance.set(AlarmManager.RTC_WAKEUP, scheduleCandidate, alarmPendingIntent); + + + SimpleDateFormat sdf = new SimpleDateFormat("E dd.MM.yyyy HH:mm"); + Calendar calendar = Calendar.getInstance(); + calendar.setTimeInMillis(scheduleCandidate); + Miscellaneous.logEvent("i", "AlarmManager", "Chose " + sdf.format(calendar.getTime()) + " as next scheduled alarm.", 4); + + } + + public static void clearAlarms() + { + Miscellaneous.logEvent("i", "AlarmManager", "Clearing possibly standing alarms.", 4); + for(int requestCode : requestCodeList) + { + Intent alarmIntent = new Intent(automationServiceRef, AlarmListener.class); + PendingIntent alarmPendingIntent = PendingIntent.getBroadcast(automationServiceRef, requestCode, alarmIntent, 0); +// Miscellaneous.logEvent("i", "AlarmManager", "Clearing alarm with request code: " + String.valueOf(requestCode)); + centralAlarmManagerInstance.cancel(alarmPendingIntent); + } + requestCodeList.clear(); + } + + private static void startAlarmListenerInternal(AutomationService givenAutomationServiceRef) + { + if(!alarmListenerActive) + { + Miscellaneous.logEvent("i", "AlarmListener", "Starting alarm listener.", 4); + AlarmListener.automationServiceRef = givenAutomationServiceRef; + centralAlarmManagerInstance = (AlarmManager)automationServiceRef.getSystemService(automationServiceRef.ALARM_SERVICE); +// alarmIntent = new Intent(automationServiceRef, AlarmListener.class); +// alarmPendingIntent = PendingIntent.getBroadcast(automationServiceRef, 0, alarmIntent, 0); + alarmListenerActive = true; + Miscellaneous.logEvent("i", "AlarmListener", "Alarm listener started.", 4); + AlarmListener.setAlarms(); + +// // get a Calendar object with current time +// Calendar cal = Calendar.getInstance(); +// // add 5 minutes to the calendar object +// cal.add(Calendar.SECOND, 10); +// centralAlarmManagerInstance.setInexactRepeating(AlarmManager.RTC_WAKEUP, cal.getTimeInMillis(), 5000, alarmPendingIntent); + } + else + Miscellaneous.logEvent("i", "AlarmListener", "Request to start AlarmListener. But it's already active.", 5); + } + + private static void stopAlarmListenerInternal() + { + if(alarmListenerActive) + { + Miscellaneous.logEvent("i", "AlarmListener", "Stopping alarm listener.", 4); + clearAlarms(); +// centralAlarmManagerInstance.cancel(alarmPendingIntent); + alarmListenerActive = false; + } + else + Miscellaneous.logEvent("i", "AlarmListener", "Request to stop AlarmListener. But it's not running.", 5); + } + public static void reloadAlarms() + { + AlarmListener.setAlarms(); + } + @Override + public void startListener(AutomationService automationService) + { + AlarmListener.startAlarmListener(automationService); + } + @Override + public void stopListener(AutomationService automationService) + { + AlarmListener.stopAlarmListener(automationService); + } + + public static boolean haveAllPermission() + { + return true; + } + + @Override + public boolean isListenerRunning() + { + return isAlarmListenerActive(); + } + @Override + public Trigger_Enum[] getMonitoredTrigger() + { + return new Trigger_Enum[] { Trigger_Enum.timeFrame }; + } + +} diff --git a/app/src/main/java/com/jens/automation2/receivers/AutomationListenerInterface.java b/app/src/main/java/com/jens/automation2/receivers/AutomationListenerInterface.java new file mode 100644 index 0000000..a40cc6b --- /dev/null +++ b/app/src/main/java/com/jens/automation2/receivers/AutomationListenerInterface.java @@ -0,0 +1,12 @@ +package com.jens.automation2.receivers; + +import com.jens.automation2.AutomationService; +import com.jens.automation2.Trigger.Trigger_Enum; + +public interface AutomationListenerInterface +{ + public void startListener(AutomationService automationService); + public void stopListener(AutomationService automationService); + public boolean isListenerRunning(); + public Trigger_Enum[] getMonitoredTrigger(); +} diff --git a/app/src/main/java/com/jens/automation2/receivers/BatteryReceiver.java b/app/src/main/java/com/jens/automation2/receivers/BatteryReceiver.java new file mode 100644 index 0000000..0d75214 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/receivers/BatteryReceiver.java @@ -0,0 +1,314 @@ +package com.jens.automation2.receivers; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.os.BatteryManager; +import android.util.Log; +import android.widget.Toast; + +import com.jens.automation2.ActivityPermissions; +import com.jens.automation2.AutomationService; +import com.jens.automation2.Miscellaneous; +import com.jens.automation2.Rule; +import com.jens.automation2.Trigger.Trigger_Enum; + +import java.util.ArrayList; + +public class BatteryReceiver extends BroadcastReceiver implements AutomationListenerInterface +{ + private static int batteryLevel=-1; // initialize with a better value than this + public static AutomationService automationServiceRef = null; + private static boolean usbHostConnected = false; + + private static boolean batteryReceiverActive = false; + private static IntentFilter batteryIntentFilter = null; + private static Intent batteryStatus = null; + private static BroadcastReceiver batteryInfoReceiverInstance = null; + public static void startBatteryReceiver(final AutomationService automationServiceRef) + { + if(!batteryReceiverActive) + { + BatteryReceiver.automationServiceRef = automationServiceRef; + + if(batteryInfoReceiverInstance == null) + batteryInfoReceiverInstance = new BatteryReceiver(); + + if(batteryIntentFilter == null) + { + batteryIntentFilter = new IntentFilter(); + batteryIntentFilter.addAction(Intent.ACTION_BATTERY_CHANGED); + batteryIntentFilter.addAction(Intent.ACTION_BATTERY_LOW); + // batteryIntentFilter.addAction(Intent.ACTION_POWER_CONNECTED); + // batteryIntentFilter.addAction(Intent.ACTION_POWER_DISCONNECTED); + } + + batteryStatus = automationServiceRef.registerReceiver(batteryInfoReceiverInstance, batteryIntentFilter); + + batteryReceiverActive = true; + } + } + public static void stopBatteryReceiver() + { + if(batteryReceiverActive) + { + if(batteryInfoReceiverInstance != null) + { + automationServiceRef.unregisterReceiver(batteryInfoReceiverInstance); + batteryInfoReceiverInstance = null; + } + + batteryReceiverActive = false; + } + } + + public static boolean isBatteryReceiverActive() + { + return batteryReceiverActive; + } + + public static boolean isUsbHostConnected() + { + return usbHostConnected; + } + + public static int getBatteryLevel() + { + return batteryLevel; + } + + private static int deviceIsCharging = 0; //0=unknown, 1=no, 2=yes + + public static int getDeviceIsCharging() + { + return deviceIsCharging; + } + + @Override + public void onReceive(Context context, Intent intent) + { +// Log.i("Battery", "Some battery event"); + + if (intent == null) + return; + if (context == null) + return; + + if(intent.getAction().equals(Intent.ACTION_BATTERY_LOW)) + { + Log.i("Battery", "Low battery event"); + } + else + { + try + { + // Miscellaneous.logEvent("i", "BatteryReceiver", "Received battery event."); + // if(intent.getAction().equals(Intent.ACTION_BATTERY_CHANGED)) + // { + batteryLevel = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1); + // int scale = -1; + // int voltage = -1; + // int temp = -1; + // scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1); + // temp = intent.getIntExtra(BatteryManager.EXTRA_TEMPERATURE, -1); + // voltage = intent.getIntExtra(BatteryManager.EXTRA_VOLTAGE, -1); + Log.i("Battery", "Level: " + String.valueOf(batteryLevel)); + this.actionBatteryLevel(context); + + int status = intent.getIntExtra(BatteryManager.EXTRA_STATUS, -1); + int statusPlugged = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1); + // Miscellaneous.logEvent("i", "BatteryReceiver", "Status: " + String.valueOf(statusPlugged)); + + switch(statusPlugged) + { + case BatteryManager.BATTERY_PLUGGED_AC: + // Toast.makeText(context, "Regular charging", Toast.LENGTH_LONG).show(); + // Miscellaneous.logEvent("i", "BatteryReceiver", "Regular charging."); + this.actionCharging(context); + break; + case BatteryManager.BATTERY_PLUGGED_USB: + this.actionUsbConnected(context); + break; + } + + switch(status) + { + // case BatteryManager.BATTERY_STATUS_CHARGING: + // break; + case BatteryManager.BATTERY_STATUS_FULL: + // Toast.makeText(context, "Regular charging full", Toast.LENGTH_LONG).show(); + // Miscellaneous.logEvent("i", "BatteryReceiver", "Device has been fully charged."); + this.actionCharging(context); + break; + case BatteryManager.BATTERY_STATUS_DISCHARGING: + this.actionDischarging(context); + break; + } + // } + // else if(intent.getAction().equals(Intent.ACTION_POWER_CONNECTED)) + // { + //// Miscellaneous.logEvent("i", "BatteryReceiver", "Battery is charging or full."); + // deviceIsCharging = 2; + // //activate rule(s) + // ArrayList ruleCandidates = Rule.findRuleCandidatesByCharging(true); + // for(int i=0; i ruleCandidates = Rule.findRuleCandidatesByCharging(false); + // for(int i=0; i ruleCandidates = Rule.findRuleCandidatesByCharging(true); + for(int i=0; i ruleCandidates = Rule.findRuleCandidatesByBatteryLevel(); + for(int i=0; i ruleCandidates = Rule.findRuleCandidatesByCharging(false); + for(int i=0; i ruleCandidates = Rule.findRuleCandidatesByUsbHost(true); + for(Rule oneRule : ruleCandidates) + { + if(oneRule.applies(context)) + oneRule.activate(automationServiceRef, false); + } + + this.actionCharging(context); + } + } + + private void actionUsbDisconnected(Context context) + { + // Event usbDisConnected + + if(usbHostConnected) + { + usbHostConnected = false; + Miscellaneous.logEvent("i", "BatteryReceiver", "Disconnected from computer.", 3); + Toast.makeText(context, "Disconnected from computer.", Toast.LENGTH_LONG).show(); + + ArrayList ruleCandidates = Rule.findRuleCandidatesByUsbHost(false); + for(Rule oneRule : ruleCandidates) + { + if(oneRule.applies(context)) + oneRule.activate(automationServiceRef, false); + } + } + } + @Override + public void startListener(AutomationService automationService) + { + BatteryReceiver.startBatteryReceiver(automationService); + } + @Override + public void stopListener(AutomationService automationService) + { + BatteryReceiver.stopBatteryReceiver(); + } + + public static boolean haveAllPermission() + { + return ActivityPermissions.havePermission("android.permission.READ_PHONE_STATE", Miscellaneous.getAnyContext()) && + ActivityPermissions.havePermission("android.permission.BATTERY_STATS", Miscellaneous.getAnyContext()); + } + + @Override + public boolean isListenerRunning() + { + return BatteryReceiver.isBatteryReceiverActive(); + } + @Override + public Trigger_Enum[] getMonitoredTrigger() + { + // actually monitores several + return new Trigger_Enum[] { Trigger_Enum.batteryLevel, Trigger_Enum.charging, Trigger_Enum.usb_host_connection }; + } +} diff --git a/app/src/main/java/com/jens/automation2/receivers/BluetoothReceiver.java b/app/src/main/java/com/jens/automation2/receivers/BluetoothReceiver.java new file mode 100644 index 0000000..0415c78 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/receivers/BluetoothReceiver.java @@ -0,0 +1,303 @@ +package com.jens.automation2.receivers; + +import android.bluetooth.BluetoothAdapter; +import android.bluetooth.BluetoothDevice; +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.util.Log; + +import com.jens.automation2.ActivityPermissions; +import com.jens.automation2.AutomationService; +import com.jens.automation2.Miscellaneous; +import com.jens.automation2.R; +import com.jens.automation2.Rule; +import com.jens.automation2.Trigger.Trigger_Enum; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.Set; + +public class BluetoothReceiver extends BroadcastReceiver implements AutomationListenerInterface +{ + protected static ArrayList connectedDevices = new ArrayList(); + protected static ArrayList devicesInRange = new ArrayList(); + + protected static BluetoothDevice lastAffectedDevice = null; + protected static String lastAction = null; + + protected static IntentFilter bluetoothReceiverIntentFilter = null; + protected static boolean bluetoothReceiverActive = false; + protected static BluetoothReceiver bluetoothReceiverInstance = null; + + public static boolean isBluetoothReceiverActive() + { + return bluetoothReceiverActive; + } + + public static void startBluetoothReceiver() + { + if(bluetoothReceiverInstance == null) + bluetoothReceiverInstance = new BluetoothReceiver(); + + if(bluetoothReceiverIntentFilter == null) + { + bluetoothReceiverIntentFilter = new IntentFilter(); + bluetoothReceiverIntentFilter.addAction(BluetoothDevice.ACTION_ACL_CONNECTED); + bluetoothReceiverIntentFilter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECT_REQUESTED); + bluetoothReceiverIntentFilter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED); + } + + try + { + if(!bluetoothReceiverActive) + { + Miscellaneous.logEvent("i", "BluetoothReceiver", "Starting BluetoothReceiver", 4); + bluetoothReceiverActive = true; + AutomationService.getInstance().registerReceiver(bluetoothReceiverInstance, bluetoothReceiverIntentFilter); + } + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", "BluetoothReceiver", "Error starting BluetoothReceiver: " + Log.getStackTraceString(ex), 3); + } + } + public static void stopBluetoothReceiver() + { + try + { + if(bluetoothReceiverActive) + { + Miscellaneous.logEvent("i", "BluetoothReceiver", "Stopping BluetoothReceiver", 4); + bluetoothReceiverActive = false; + AutomationService.getInstance().unregisterReceiver(bluetoothReceiverInstance); + } + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", "BluetoothReceiver", "Error stopping BluetoothReceiver: " + Log.getStackTraceString(ex), 3); + } + } + + public static BluetoothDevice getLastAffectedDevice() + { + return lastAffectedDevice; + } + + public static String getLastAction() + { + return lastAction; + } + + @Override + public void onReceive(Context context, Intent intent) + { +// Miscellaneous.logEvent("i", "BluetoothReceiver", "Bluetooth event.", 4); + + String action = intent.getAction(); + BluetoothDevice bluetoothDevice = null; + + if(action.equals(BluetoothDevice.ACTION_ACL_CONNECTED) | action.equals("android.bluetooth.device.action.ACL_CONNECTED")) + { + bluetoothDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE); + lastAffectedDevice = bluetoothDevice; + lastAction = action; + connectedDevices.add(bluetoothDevice); + Miscellaneous.logEvent("i", "BluetoothReceiver", String.format(context.getResources().getString(R.string.bluetoothConnectionTo), bluetoothDevice.getName()), 3); + } + else if(action.equals(BluetoothDevice.ACTION_ACL_DISCONNECTED) | action.equals(BluetoothDevice.ACTION_ACL_DISCONNECT_REQUESTED) | action.equals("android.bluetooth.device.ACTION_ACL_DISCONNECTED") | action.equals("android.bluetooth.device.ACTION_ACL_DISCONNECT_REQUESTED")) + { + bluetoothDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE); + lastAffectedDevice = bluetoothDevice; + lastAction = action; + connectedDevices.remove(bluetoothDevice); + Miscellaneous.logEvent("i", "BluetoothReceiver", String.format(context.getResources().getString(R.string.bluetoothDisconnectFrom), bluetoothDevice.getName()), 3); + } + else if(action.equals(BluetoothDevice.ACTION_FOUND) | action.equals("android.bluetooth.device.ACTION_FOUND")) + { + bluetoothDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE); + lastAffectedDevice = bluetoothDevice; + lastAction = action; + devicesInRange.add(bluetoothDevice); + Miscellaneous.logEvent("i", "BluetoothReceiver", String.format(context.getResources().getString(R.string.bluetoothDeviceInRange), bluetoothDevice.getName()), 3); + } + + ArrayList ruleCandidates = Rule.findRuleCandidatesByBluetoothConnection(); + for(int i=0; i deviceList = BluetoothAdapter.getDefaultAdapter().getBondedDevices(); + returnArray = deviceList.toArray(new BluetoothDevice[deviceList.size()]); + + Arrays.sort(returnArray, new Comparator() + { + @Override + public int compare(BluetoothDevice lhs, BluetoothDevice rhs) + { + return lhs.getName().compareTo(rhs.getName()); + } + + ; + }); + } + catch(NullPointerException e) + { + // There are no paired bluetooth devices. + + returnArray = new BluetoothDevice[] {}; + } + + return returnArray; + } + + public static String[] getAllPairedBluetoothDevicesStrings() + { + ArrayList names = new ArrayList(); + for(BluetoothDevice device : getAllPairedBluetoothDevices()) + names.add(device.getName() + " (" + device.getAddress() + ")"); + + return names.toArray(new String[names.size()]); + } + + public static BluetoothDevice getDeviceByName(String name) + { + for(BluetoothDevice device : getAllPairedBluetoothDevices()) + { + if(device.getName().equals(name)) + return device; + } + + return null; + } + + public static BluetoothDevice getDeviceByAddress(String address) + { + for(BluetoothDevice device : getAllPairedBluetoothDevices()) + { + if(device.getAddress().equals(address)) + return device; + } + + return null; + } + + public static int getDevicePositionByAddress(String address) + { + BluetoothDevice[] allDevices = getAllPairedBluetoothDevices(); + for(int i=0; i 0) + return true; + else + return false; + } + + public static boolean isAnyDeviceInRange() + { + if(devicesInRange.size() > 0) + return true; + else + return false; + } + + public static boolean isDeviceInRange(BluetoothDevice searchDevice) + { + for(BluetoothDevice device : devicesInRange) + if(device.getAddress().equals(searchDevice.getAddress())) + return true; + + return false; + } + + private void discovery() + { + BluetoothAdapter.getDefaultAdapter().startDiscovery(); + BroadcastReceiver discoveryReceiver = new BroadcastReceiver() + { + public void onReceive(Context context, Intent intent) + { + String action = intent.getAction(); + //ACTION_DISCOVERY_STARTED and ACTION_DISCOVERY_FINISHED + if(action.equals(BluetoothAdapter.ACTION_DISCOVERY_FINISHED)) + { + // This would be a good point to look for devices that are not in range anymore. + } + } + }; + } + + @Override + public void startListener(AutomationService automationService) + { + BluetoothReceiver.startBluetoothReceiver(); + } + + @Override + public void stopListener(AutomationService automationService) + { + BluetoothReceiver.stopBluetoothReceiver(); + } + + public static boolean haveAllPermission() + { + return ActivityPermissions.havePermission("android.permission.BLUETOOTH_ADMIN", Miscellaneous.getAnyContext()) && + ActivityPermissions.havePermission("android.permission.BLUETOOTH", Miscellaneous.getAnyContext()) && + ActivityPermissions.havePermission("android.permission.ACCESS_NETWORK_STATE", Miscellaneous.getAnyContext()); + } + + @Override + public boolean isListenerRunning() + { + return BluetoothReceiver.isBluetoothReceiverActive(); + } + + @Override + public Trigger_Enum[] getMonitoredTrigger() + { + return new Trigger_Enum[] { Trigger_Enum.bluetoothConnection }; + } +} diff --git a/app/src/main/java/com/jens/automation2/receivers/ConnectivityReceiver.java b/app/src/main/java/com/jens/automation2/receivers/ConnectivityReceiver.java new file mode 100644 index 0000000..43e0b70 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/receivers/ConnectivityReceiver.java @@ -0,0 +1,263 @@ +package com.jens.automation2.receivers; + +import android.annotation.SuppressLint; +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.net.ConnectivityManager; +import android.net.NetworkInfo; +import android.net.wifi.WifiInfo; +import android.net.wifi.WifiManager; +import android.os.Build; +import android.telephony.TelephonyManager; +import android.util.Log; + +import com.jens.automation2.ActivityPermissions; +import com.jens.automation2.AutomationService; +import com.jens.automation2.Miscellaneous; +import com.jens.automation2.Rule; +import com.jens.automation2.Trigger.Trigger_Enum; +import com.jens.automation2.location.WifiBroadcastReceiver; + +import java.util.ArrayList; + +public class ConnectivityReceiver extends BroadcastReceiver implements AutomationListenerInterface +{ + protected static boolean connectivityReceiverActive = false; + private static ConnectivityReceiver connectivityReceiverInstance = null; + private static IntentFilter connectivityIntentFilter = null; + private static AutomationService automationServiceRef = null; + protected static boolean dataConnectionLastState = false; + protected static boolean roamingLastState = false; + + public static boolean isConnectivityReceiverActive() + { + return connectivityReceiverActive; + } + + public static void startConnectivityReceiver(AutomationService ref) + { + automationServiceRef = ref; + + if(connectivityReceiverInstance == null) + connectivityReceiverInstance = new ConnectivityReceiver(); + + + if(connectivityIntentFilter == null) + { + connectivityIntentFilter = new IntentFilter(); + connectivityIntentFilter.addAction(Intent.ACTION_AIRPLANE_MODE_CHANGED); + connectivityIntentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION); + } + + try + { + if(!connectivityReceiverActive) + { + Miscellaneous.logEvent("i", "Wifi Listener", "Starting connectivityReceiver", 4); + connectivityReceiverActive = true; + automationServiceRef.registerReceiver(connectivityReceiverInstance, connectivityIntentFilter); + } + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", "Wifi Listener", "Error starting connectivityReceiver: " + Log.getStackTraceString(ex), 3); + } + } + + + public static void stopConnectivityReceiver() + { + try + { + if(connectivityReceiverActive) + { + Miscellaneous.logEvent("i", "Wifi Listener", "Stopping connectivityReceiver", 4); + connectivityReceiverActive = false; + automationServiceRef.unregisterReceiver(connectivityReceiverInstance); + } + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", "Wifi Listener", "Error stopping connectivityReceiver: " + Log.getStackTraceString(ex), 3); + } + } + + // Get roaming state from telephony manager + public static Boolean isRoaming(Context context) + { + TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); + return telephonyManager.isNetworkRoaming(); + } + + public static void setDataConnectionLastState(boolean newState) + { + if(dataConnectionLastState != newState) + { + dataConnectionLastState = newState; + + // Run rules if I decide to create such a trigger +// automationServiceRef.getLocationProvider().handleDataConnectionChange(newState); + } + } + public static Boolean isDataConnectionAvailable(Context context) + { + ConnectivityManager connManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); + NetworkInfo ni = connManager.getActiveNetworkInfo(); + return ni != null && ni.isConnected(); + } + + // Get airplane mode state from system settings + @SuppressLint("NewApi") + public static boolean isAirplaneMode(Context context) + { + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR1) + { + int value = android.provider.Settings.System.getInt(context.getContentResolver(), android.provider.Settings.System.AIRPLANE_MODE_ON, 0); + return value != 0; + } + else + { + return android.provider.Settings.Global.getInt(context.getContentResolver(), android.provider.Settings.Global.AIRPLANE_MODE_ON, 0) != 0; + } + } + + @Override + public void onReceive(Context context, Intent intent) + { + try + { + if (context == null) + return; + + if(intent.getAction().equals(Intent.ACTION_AIRPLANE_MODE_CHANGED)) + { + // Airplane mode status has changed. + Miscellaneous.logEvent("i", "Connectivity", "Airplane mode changed.", 2); + boolean isAirplaneMode = isAirplaneMode(context); + automationServiceRef.getLocationProvider().handleAirplaneMode(isAirplaneMode); + + ArrayList ruleCandidates = Rule.findRuleCandidatesByAirplaneMode(isAirplaneMode); + for(int i=0; i ruleCandidates = Rule.findRuleCandidatesByRoaming(isRoaming); + for(int i=0; i ruleCandidates = Rule.findRuleCandidatesByRoaming(isRoaming); +// for(int i=0; ionReceive(): " + Log.getStackTraceString(e), 3); + } + } + + @Override + public void startListener(AutomationService automationService) + { + ConnectivityReceiver.startConnectivityReceiver(automationService); + } + + @Override + public void stopListener(AutomationService automationService) + { + ConnectivityReceiver.stopConnectivityReceiver(); + } + + public static boolean haveAllPermission() + { + return ActivityPermissions.havePermission("android.permission.ACCESS_NETWORK_STATE", Miscellaneous.getAnyContext()) && + ActivityPermissions.havePermission("android.permission.ACCESS_WIFI_STATE", Miscellaneous.getAnyContext()) && + ActivityPermissions.havePermission("android.permission.ACCESS_NETWORK_STATE", Miscellaneous.getAnyContext()); + } + + @Override + public boolean isListenerRunning() + { + return ConnectivityReceiver.isConnectivityReceiverActive(); + } + + @Override + public Trigger_Enum[] getMonitoredTrigger() + { + return new Trigger_Enum[] { Trigger_Enum.airplaneMode, Trigger_Enum.roaming, Trigger_Enum.wifiConnection }; + } +} diff --git a/app/src/main/java/com/jens/automation2/receivers/HeadphoneJackListener.java b/app/src/main/java/com/jens/automation2/receivers/HeadphoneJackListener.java new file mode 100644 index 0000000..fc37718 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/receivers/HeadphoneJackListener.java @@ -0,0 +1,152 @@ +package com.jens.automation2.receivers; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.util.Log; + +import com.jens.automation2.ActivityPermissions; +import com.jens.automation2.AutomationService; +import com.jens.automation2.Miscellaneous; +import com.jens.automation2.Rule; +import com.jens.automation2.Trigger.Trigger_Enum; + +import java.util.ArrayList; + +public class HeadphoneJackListener extends BroadcastReceiver implements AutomationListenerInterface +{ + private static boolean headsetConnected = false; + private static int headphoneType = -1; + + protected static boolean headphoneJackListenerActive=false; + protected static IntentFilter headphoneJackListenerIntentFilter = null; + protected static HeadphoneJackListener instance; + + public static HeadphoneJackListener getInstance() + { + if(instance == null) + instance = new HeadphoneJackListener(); + + return instance; + } + + public static boolean isHeadphoneJackListenerActive() + { + return headphoneJackListenerActive; + } + + + public static boolean isHeadsetConnected() + { + return headsetConnected; + } + + public static int getHeadphoneType() + { + return headphoneType; + } + + @Override + public void onReceive(Context context, Intent intent) + { + try + { + /*Broadcast Action: Wired Headset plugged in or unplugged. + The intent will have the following extra values: + + state - 0 for unplugged, 1 for plugged. + name - Headset type, human readable string + microphone - 1 if headset has a microphone, 0 otherwise*/ + + int state = intent.getExtras().getInt("state"); + String name = intent.getExtras().getString("name"); + headphoneType = intent.getExtras().getInt("microphone"); + + if(state == 0) + { + headsetConnected = false; + Miscellaneous.logEvent("i", "HeadphoneJackListener", "Headset " + name + " unplugged.", 4); + } + else + { + headsetConnected = true; + Miscellaneous.logEvent("i", "HeadphoneJackListener", "Headset " + name + " plugged in.", 4); + } + + ArrayList ruleCandidates = Rule.findRuleCandidatesByHeadphoneJack(isHeadsetConnected()); + for(int i=0; i + { + @Override + protected String doInBackground(Tag... params) + { + Tag tag = params[0]; + + Ndef ndef = Ndef.get(tag); + if (ndef == null) + { + // NDEF is not supported by this Tag. + return null; + } + NdefMessage ndefMessage = ndef.getCachedNdefMessage(); + NdefRecord[] records = ndefMessage.getRecords(); + for (NdefRecord ndefRecord : records) + { + if (ndefRecord.getTnf() == NdefRecord.TNF_WELL_KNOWN && Arrays.equals(ndefRecord.getType(), NdefRecord.RTD_TEXT)) + { + try + { + return readText(ndefRecord); + } + catch (UnsupportedEncodingException e) + { + Miscellaneous.logEvent("e", "NFC", Miscellaneous.getAnyContext().getString(R.string.nfcUnsupportedEncoding) + " " + Log.getStackTraceString(e), 3); + } + } + } + return null; + +// return readTag(tag); + } + + @Override + protected void onPostExecute(String result) + { + if (result != null && result.length() > 0) + { + // Text of tag is now stored in variable "result" + lastReadLabel = result; + Miscellaneous.logEvent("i", "NFC", Miscellaneous.getAnyContext().getResources().getString(R.string.nfcTagFoundWithText) + " " + result, 3); + Toast.makeText(Miscellaneous.getAnyContext(), Miscellaneous.getAnyContext().getResources().getString(R.string.nfcTagFoundWithText) + " " + result, Toast.LENGTH_LONG).show(); + + AutomationService asInstance = AutomationService.getInstance(); + if(asInstance == null) + { + Context context = Miscellaneous.getAnyContext(); + if(context != null) + { + Miscellaneous.logEvent("w", "NFC", context.getResources().getString(R.string.serviceNotRunning) + " " + context.getResources().getString(R.string.cantRunRule), 4); + Toast.makeText(context, context.getResources().getString(R.string.serviceNotRunning) + " " + context.getResources().getString(R.string.cantRunRule), Toast.LENGTH_LONG).show(); + } + } + else + { + ArrayList allRulesWithNfcTags = Rule.findRuleCandidatesByNfc(); + for(int i=0; i + { + @Override + protected Boolean doInBackground(Object... params) + { + String textToWrite = (String)params[0]; + Tag tagToWrite = (Tag)params[1]; + return writeTag(textToWrite, tagToWrite); + } + +// @Override +// protected void onPostExecute(Boolean result) +// { +// return result; +// } + } + + public static String readTag(Tag tag) + { +// if(tag == null) +// { +// Toast.makeText(Miscellaneous.getAnyContext(), Miscellaneous.getAnyContext().getResources().getString(R.string.nfcNoTag), Toast.LENGTH_LONG).show(); +// return null; +// } + + Ndef ndef = Ndef.get(tag); + if (ndef == null) + { + // NDEF is not supported by this Tag. + return null; + } + + NdefMessage ndefMessage = ndef.getCachedNdefMessage(); + + NdefRecord[] records = ndefMessage.getRecords(); + for (NdefRecord ndefRecord : records) + { + if (ndefRecord.getTnf() == NdefRecord.TNF_WELL_KNOWN && Arrays.equals(ndefRecord.getType(), NdefRecord.RTD_TEXT)) + { + try + { + return readText(ndefRecord); + } + catch (UnsupportedEncodingException e) + { + Miscellaneous.logEvent("w", "NFC", "Unsupported Encoding: " + Log.getStackTraceString(e), 3); + } + } + } + + return null; + } + + private static String readText(NdefRecord record) throws UnsupportedEncodingException + { + /* + * See NFC forum specification for "Text Record Type Definition" at 3.2.1 + * + * http://www.nfc-forum.org/specs/ + * + * bit_7 defines encoding + * bit_6 reserved for future use, must be 0 + * bit_5..0 length of IANA language code + */ + + byte[] payload = record.getPayload(); + + // Get the Text Encoding + String textEncoding = ((payload[0] & 128) == 0) ? "UTF-8" : "UTF-16"; + + // Get the Language Code + int languageCodeLength = payload[0] & 0063; + + // String languageCode = new String(payload, 1, languageCodeLength, "US-ASCII"); + // e.g. "en" + + // Get the Text + return new String(payload, languageCodeLength + 1, payload.length - languageCodeLength - 1, textEncoding); + } + + public static boolean writeTag(String textToWrite, Tag tag) + { + Miscellaneous.logEvent("i", "NFC", "Attempting to write tag...", 2); + + String packageName = Miscellaneous.getAnyContext().getPackageName(); + NdefRecord appRecord = NdefRecord.createApplicationRecord(packageName); + // Record with actual data we care about + byte[] textBytes = textToWrite.getBytes(); + byte[] textPayload = new byte[textBytes.length + 3]; + textPayload[0] = 0x02; // 0x02 = UTF8 + textPayload[1] = 'e'; // Language = en + textPayload[2] = 'n'; + System.arraycopy(textBytes, 0, textPayload, 3, textBytes.length); + NdefRecord textRecord = new NdefRecord(NdefRecord.TNF_WELL_KNOWN, NdefRecord.RTD_TEXT, new byte[0], textPayload); + + // Complete NDEF message with both records + NdefMessage completeMessageToWrite = new NdefMessage(new NdefRecord[] {textRecord, appRecord}); + + int size = completeMessageToWrite.toByteArray().length; + try + { + Ndef ndef = Ndef.get(tag); + if (ndef != null) + { + ndef.connect(); + if (ndef.isWritable() && ndef.getMaxSize() > size) + { + ndef.writeNdefMessage(completeMessageToWrite); + Miscellaneous.logEvent("i", "NFC", "Done writing tag.", 2); + return true; + } + } + else + { + NdefFormatable format = NdefFormatable.get(tag); + if (format != null) + { + try + { + format.connect(); + format.format(completeMessageToWrite); + Miscellaneous.logEvent("i", "NFC", "Done writing tag.", 2); + return true; + } + catch(IOException e) + { + Miscellaneous.logEvent("e", "NFC", "Error writing tag: " + Log.getStackTraceString(e), 2); + } + } + } + } + catch(Exception e) + { + Miscellaneous.logEvent("e", "NFC", "Error writing tag: " + Log.getStackTraceString(e), 2); + } + + return false; + } + + public static boolean checkNfcRequirements(Context context, boolean showErrorMessage) + { + if(!context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_NFC)) + { + if(showErrorMessage) + Toast.makeText(context, context.getResources().getString(R.string.deviceDoesNotHaveNfc), Toast.LENGTH_LONG).show(); + + return false; + } + else if(Build.VERSION.SDK_INT <= 10) + { + // NFC not supported until after Gingerbread. + if(showErrorMessage) + Toast.makeText(context, context.getResources().getString(R.string.nfcNotSupportedInThisAndroidVersionYet), Toast.LENGTH_LONG).show(); + + return false; + } + + return true; + } +} diff --git a/app/src/main/java/com/jens/automation2/receivers/NoiseListener.java b/app/src/main/java/com/jens/automation2/receivers/NoiseListener.java new file mode 100644 index 0000000..7ae0442 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/receivers/NoiseListener.java @@ -0,0 +1,215 @@ +package com.jens.automation2.receivers; + +import android.media.MediaRecorder; +import android.os.Bundle; +import android.os.Handler; +import android.os.Message; + +import com.jens.automation2.ActivityPermissions; +import com.jens.automation2.AutomationService; +import com.jens.automation2.Miscellaneous; +import com.jens.automation2.Rule; +import com.jens.automation2.Settings; +import com.jens.automation2.Trigger.Trigger_Enum; + +import java.util.ArrayList; + +public class NoiseListener implements AutomationListenerInterface +{ + private static AutomationService automationService; + private static boolean isMeasuringActive = false; + private static boolean isTimerActive = false; + private static long noiseLevelDb; + private static Handler workHandler = new Handler() + { + @Override + public void handleMessage(Message msg) + { + Miscellaneous.logEvent("i", "Noise level", "Message received stating measurement is complete.", 5); + // This will take care of results delivered by the actual measuring instance + noiseLevelDb = msg.getData().getLong("noiseLevelDb"); + + // execute matching rules containing noise + ArrayList ruleCandidates = Rule.findRuleCandidatesByNoiseLevel(); + for(Rule oneRule : ruleCandidates) + { + if(oneRule.applies(automationService)) + oneRule.activate(automationService, false); + } + } + }; + private static NoiseListenerMeasuring listener; + + private static boolean stopRequested = false; + private static Handler schedulingHandler = new Handler() + { + @Override + public void handleMessage(Message msg) + { + if(msg.arg1 == 1) + { + if(!stopRequested) + { + if(listener == null) + listener = new NoiseListenerMeasuring(); + listener.doMeasuring(); + Miscellaneous.logEvent("i", "Noise level", "Rearming noise level message.", 5); + Message message = new Message(); + message.arg1 = 1; + schedulingHandler.sendMessageDelayed(message, Settings.timeBetweenNoiseLevelMeasurements * 1000); + } + else + Miscellaneous.logEvent("i", "Noise level", "Not rearming noise level message, stop requested.", 5); + } + } + + }; + + private static class NoiseListenerMeasuring + { + Thread measuringThread; + + public void doMeasuring() + { + measuringThread = new Thread() + { + @Override + public void run() + { + if(!isMeasuringActive) + { + isMeasuringActive = true; + + Miscellaneous.logEvent("i", "Noise level", "Periodic noise level measurement started.", 5); + + // Start recording but don't store data + MediaRecorder mediaRecorder = new MediaRecorder(); + mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC); + mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP); + mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB); + mediaRecorder.setOutputFile("/dev/null"); + // Date myDate = new Date(); + // mediaRecorder.setOutputFile("/sdcard/temp/" + String.valueOf(myDate.getTime()) + ".3gpp"); + try + { + mediaRecorder.prepare(); + mediaRecorder.getMaxAmplitude(); + mediaRecorder.start(); + mediaRecorder.getMaxAmplitude(); + + long noiseLevel; + + try + { + sleep(Settings.lengthOfNoiseLevelMeasurements * 1000); + // Obtain maximum amplitude since last call of getMaxAmplitude() + noiseLevel = mediaRecorder.getMaxAmplitude(); + } + catch(Exception e) + { + noiseLevel = -1; + Miscellaneous.logEvent("e", "Noise level", "Error getting sound level: " + e.getMessage(), 2); + } + + double db = 20 * Math.log(noiseLevel / Settings.referenceValueForNoiseLevelMeasurements); + noiseLevelDb = Math.round(db); + + Message answer = new Message(); + Bundle answerBundle = new Bundle(); + answerBundle.putLong("noiseLevelDb", noiseLevelDb); + answer.setData(answerBundle); + workHandler.sendMessage(answer); + + Miscellaneous.logEvent("i", "Noise level", "Measured noise level: " + String.valueOf(noiseLevel) + " / converted to db: " + String.valueOf(db), 3); + + // Don't forget to release + mediaRecorder.reset(); + mediaRecorder.release(); + } + catch(Exception e) + {} + + isMeasuringActive = false; + + Miscellaneous.logEvent("i", "Noise level", "Periodic noise level measurement stopped.", 5); + } + } + }; + + measuringThread.start(); + } + + public void interrupt() + { + measuringThread.interrupt(); + } + } + + public static void startNoiseListener(AutomationService newAutomationService) + { + automationService = newAutomationService; + + if(!isTimerActive) + { + Miscellaneous.logEvent("i", "Noise level", "Starting periodic noise level measurement engine.", 2); + isTimerActive = true; + + Message message = new Message(); + message.arg1 = 1; + schedulingHandler.sendMessageDelayed(message, Settings.timeBetweenNoiseLevelMeasurements * 1000); + } + else + Miscellaneous.logEvent("i", "Noise level", "Periodic noise level measurement is already running. Won't start it again.", 2); + } + public static void stopNoiseListener() + { + if(isTimerActive) + { + stopRequested = true; + Miscellaneous.logEvent("i", "Noise level", "Stopping periodic noise level measurement engine.", 2); + + if(schedulingHandler.hasMessages(1)) + schedulingHandler.removeMessages(1); + + if(listener != null) + listener.interrupt(); + + isTimerActive = false; + } + else + Miscellaneous.logEvent("i", "Noise level", "Periodic noise level measurement is not active. Can't stop it.", 2); + } + + public static long getNoiseLevelDb() + { + return noiseLevelDb; + } + + @Override + public void startListener(AutomationService automationService) + { + NoiseListener.startNoiseListener(automationService); + } + @Override + public void stopListener(AutomationService automationService) + { + NoiseListener.stopNoiseListener(); + } + + public static boolean haveAllPermission() + { + return ActivityPermissions.havePermission("android.permission.RECORD_AUDIO", Miscellaneous.getAnyContext()); + } + + @Override + public boolean isListenerRunning() + { + return NoiseListener.isMeasuringActive | NoiseListener.isTimerActive; + } + @Override + public Trigger_Enum[] getMonitoredTrigger() + { + return new Trigger_Enum[] { Trigger_Enum.noiseLevel }; + } + +} diff --git a/app/src/main/java/com/jens/automation2/receivers/PackageReplacedReceiver.java b/app/src/main/java/com/jens/automation2/receivers/PackageReplacedReceiver.java new file mode 100644 index 0000000..de80fd0 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/receivers/PackageReplacedReceiver.java @@ -0,0 +1,56 @@ +package com.jens.automation2.receivers; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; + +import com.jens.automation2.AutomationService; +import com.jens.automation2.Miscellaneous; +import com.jens.automation2.R; +import com.jens.automation2.Settings; + +public class PackageReplacedReceiver extends BroadcastReceiver +{ + @Override + public void onReceive(Context context, Intent intent) + { +// Toast.makeText(context, "package replaced", Toast.LENGTH_LONG).show(); +// int intentUid = intent.getExtras().getInt("android.intent.extra.UID"); // userid of the application that has just been updated +// int myUid = android.os.Process.myUid(); // userid of this application +// +// boolean replacing = intent.getBooleanExtra(Intent.EXTRA_REPLACING, false); + +// if(intentUid == myUid) +// { + Settings.readFromPersistentStorage(context); + + Miscellaneous.logEvent("i", context.getResources().getString(R.string.applicationHasBeenUpdated), context.getResources().getString(R.string.applicationHasBeenUpdated), 2); + if(hasServiceBeenRunning() && Settings.startServiceAfterAppUpdate) + { + Miscellaneous.logEvent("i", "Service", context.getResources().getString(R.string.logStartingServiceAfterAppUpdate), 1); + AutomationService.startAutomationService(context, true); + } + else + { + Miscellaneous.logEvent("i", "Service", context.getResources().getString(R.string.logNotStartingServiceAfterAppUpdate), 2); + } +// } +// else +// Miscellaneous.logEvent("i", "Service", "Some other app has been updated.", 5); + } + + private static boolean hasServiceBeenRunning() + { + return Settings.hasServiceBeenRunning; + } + + public static void setHasServiceBeenRunning(boolean state, Context context) + { + Miscellaneous.logEvent("i", "State", "Writing stateFile to " + String.valueOf(state), 4); + Settings.readFromPersistentStorage(context); +// Settings.initializeSettings(context, false); + Settings.hasServiceBeenRunning = state; + Settings.writeSettings(context); + } + +} diff --git a/app/src/main/java/com/jens/automation2/receivers/PhoneStatusListener.java b/app/src/main/java/com/jens/automation2/receivers/PhoneStatusListener.java new file mode 100644 index 0000000..16f7671 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/receivers/PhoneStatusListener.java @@ -0,0 +1,331 @@ +package com.jens.automation2.receivers; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.telephony.PhoneStateListener; +import android.telephony.TelephonyManager; +import android.util.Log; + +import com.jens.automation2.ActivityPermissions; +import com.jens.automation2.AutomationService; +import com.jens.automation2.Miscellaneous; +import com.jens.automation2.R; +import com.jens.automation2.Rule; +import com.jens.automation2.Trigger.Trigger_Enum; + +import java.util.ArrayList; + +public class PhoneStatusListener implements AutomationListenerInterface +{ + protected static int currentStateIncoming = -1; + protected static int currentStateOutgoing = -1; + protected static String lastPhoneNumber=""; + protected static int lastPhoneDirection = -1; //0=incoming, 1=outgoing + + protected static boolean incomingCallsReceiverActive = false; + protected static boolean outgoingCallsReceiverActive = false; + + protected static IntentFilter outgoingCallsIntentFilter; + protected static IncomingCallsReceiver incomingCallsReceiverInstance; + protected static BroadcastReceiver outgoingCallsReceiverInstance; + + + public static boolean isIncomingCallsReceiverActive() + { + return incomingCallsReceiverActive; + } + + public static boolean isOutgoingCallsReceiverActive() + { + return outgoingCallsReceiverActive; + } + + protected static boolean receivedInitialIncomingSignal = false; + + public static int getLastPhoneDirection() + { + return lastPhoneDirection; + } + + protected static void setLastPhoneNumber(String lastPhoneNumber) + { + PhoneStatusListener.lastPhoneNumber = lastPhoneNumber; + } + + public static String getLastPhoneNumber() + { + return lastPhoneNumber; + } + + public static class IncomingCallsReceiver extends PhoneStateListener + { + @Override + public void onCallStateChanged(int state, String incomingNumber) + { +// Miscellaneous.logEvent("i", "Call state", "New call state: " + String.valueOf(state), 4); + + if(incomingNumber != null && incomingNumber.length() > 0) // check for null in case call comes in with suppressed number. + setLastPhoneNumber(incomingNumber); + + switch(state) + { + case TelephonyManager.CALL_STATE_IDLE: + Miscellaneous.logEvent("i", "Call state", "New call state: CALL_STATE_IDLE", 4); + if(currentStateIncoming == TelephonyManager.CALL_STATE_OFFHOOK) + setCurrentStateIncoming(state); + else if(currentStateOutgoing == TelephonyManager.CALL_STATE_OFFHOOK) + setCurrentStateOutgoing(state); + else + currentStateIncoming = state; + currentStateOutgoing = state; + break; + case TelephonyManager.CALL_STATE_OFFHOOK: + Miscellaneous.logEvent("i", "Call state", "New call state: CALL_STATE_OFFHOOK", 4); + if(currentStateIncoming == TelephonyManager.CALL_STATE_RINGING) + setCurrentStateIncoming(state); + else if(currentStateOutgoing == TelephonyManager.CALL_STATE_RINGING) + setCurrentStateOutgoing(state); + break; + case TelephonyManager.CALL_STATE_RINGING: + String number = "unknown"; + if(incomingNumber != null && incomingNumber.length() > 0) + number = incomingNumber; + Miscellaneous.logEvent("i", "Call state", String.format(Miscellaneous.getAnyContext().getResources().getString(R.string.incomingCallFrom), number), 4); + + setCurrentStateIncoming(state); + break; + } + } + } + + public static class OutgoingCallsReceiver extends BroadcastReceiver + { + @Override + public void onReceive(Context context, Intent intent) + { + setCurrentStateOutgoing(2); + setLastPhoneNumber(intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER)); + Miscellaneous.logEvent("i", "Call state", String.format(Miscellaneous.getAnyContext().getResources().getString(R.string.outgoingCallFrom), getLastPhoneNumber()), 4); + } + } + + public static boolean isInACall() + { + if(isInIncomingCall() | isInOutgoingCall()) + return true; + + return false; + } + + public static boolean isInIncomingCall() + { +// Miscellaneous.logEvent("i", "Incoming call state", String.valueOf(currentStateIncoming), 5); + switch(currentStateIncoming) + { +// case -1: +// return false; +// case 0: +// return false; +// case 1: +// return true; + case 2: + return true; +// case 3: +// return true; +// case 4: +// return true; +// default: +// return false; + } + + return false; + } + + public static boolean isInOutgoingCall() + { +// Miscellaneous.logEvent("i", "Outgoing call state", String.valueOf(currentStateOutgoing), 5); + switch(currentStateOutgoing) + { +// case -1: +// return false; +// case 0: +// return false; +// case 1: +// return true; + case 2: + return true; +// case 3: +// return true; +// case 4: +// return true; +// default: +// return false; + } + + return false; + } + + private static void setCurrentStateIncoming(int state) + { +// Miscellaneous.logEvent("i", "Call state", "New incoming call state: " + String.valueOf(state), 4); + if(currentStateIncoming != state) + { + if(lastPhoneDirection != 1) + lastPhoneDirection = 1; + + if( + (state == 0 && currentStateIncoming == 2) + | + (state == 2 && (currentStateIncoming == 0 | currentStateIncoming == 1)) + ) + { + currentStateIncoming = state; + + ArrayList ruleCandidates = Rule.findRuleCandidatesByPhoneCall(isInIncomingCall()); + for(int i=0; i ruleCandidates = Rule.findRuleCandidatesByPhoneCall(isInOutgoingCall()); + for(int i=0; iincomingCallsReceiver", 4); + TelephonyManager tm = (TelephonyManager)automationService.getSystemService(Context.TELEPHONY_SERVICE); + tm.listen(incomingCallsReceiverInstance, PhoneStateListener.LISTEN_CALL_STATE); + incomingCallsReceiverActive = true; + } + + if(!outgoingCallsReceiverActive) + { + Miscellaneous.logEvent("i", "PhoneStatusListener", "Starting PhoneStatusListener->outgoingCallsReceiver", 4); + automationService.registerReceiver(outgoingCallsReceiverInstance, outgoingCallsIntentFilter); + outgoingCallsReceiverActive = true; + } + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", "PhoneStatusListener", "Error starting PhoneStatusListener: " + Log.getStackTraceString(ex), 3); + } + } + + public static void stopPhoneStatusListener(AutomationService automationService) + { + try + { + if(incomingCallsReceiverActive) + { + Miscellaneous.logEvent("i", "PhoneStatusListener", "Stopping phoneStatusListener", 4); + TelephonyManager tm = (TelephonyManager)automationService.getSystemService(Context.TELEPHONY_SERVICE); + tm.listen(incomingCallsReceiverInstance, PhoneStateListener.LISTEN_NONE); + incomingCallsReceiverActive = false; + } + + if(outgoingCallsReceiverActive) + { + Miscellaneous.logEvent("i", "PhoneStatusListener", "Stopping phoneStatusListener", 4); + automationService.unregisterReceiver(outgoingCallsReceiverInstance); + outgoingCallsReceiverActive = false; + } + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", "PhoneStatusListener", "Error stopping phoneStatusListener: " + Log.getStackTraceString(ex), 3); + } + } + + @Override + public void startListener(AutomationService automationService) + { + PhoneStatusListener.startPhoneStatusListener(automationService); + } + + @Override + public void stopListener(AutomationService automationService) + { + PhoneStatusListener.stopPhoneStatusListener(automationService); + } + + public static boolean haveAllPermission() + { + return + ActivityPermissions.havePermission("android.permission.READ_PHONE_STATE", Miscellaneous.getAnyContext()) + && + ActivityPermissions.havePermission(ActivityPermissions.permissionNameCall, Miscellaneous.getAnyContext()); + } + + @Override + public boolean isListenerRunning() + { + return PhoneStatusListener.incomingCallsReceiverActive | PhoneStatusListener.isOutgoingCallsReceiverActive(); + } + + @Override + public Trigger_Enum[] getMonitoredTrigger() + { + return new Trigger_Enum[] { Trigger_Enum.phoneCall }; + } +} diff --git a/app/src/main/java/com/jens/automation2/receivers/ProcessListener.java b/app/src/main/java/com/jens/automation2/receivers/ProcessListener.java new file mode 100644 index 0000000..42778dc --- /dev/null +++ b/app/src/main/java/com/jens/automation2/receivers/ProcessListener.java @@ -0,0 +1,470 @@ +package com.jens.automation2.receivers; + +import android.app.ActivityManager; +import android.app.ActivityManager.RunningAppProcessInfo; +import android.app.ActivityManager.RunningServiceInfo; +import android.app.ActivityManager.RunningTaskInfo; +import android.content.Context; +import android.os.Handler; +import android.os.Message; + +import com.jens.automation2.ActivityPermissions; +import com.jens.automation2.AutomationService; +import com.jens.automation2.Miscellaneous; +import com.jens.automation2.R; +import com.jens.automation2.Rule; +import com.jens.automation2.Settings; +import com.jens.automation2.Trigger.Trigger_Enum; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Iterator; +import java.util.List; + +public class ProcessListener implements AutomationListenerInterface +{ + private static ArrayList runningAppsList1 = new ArrayList(); + private static ArrayList runningAppsList2 = new ArrayList(); + private static int lastWritten = 2; + private static int runCounter = 0; + private static AutomationService automationService; + private static boolean isMonitoringActive = false; + private static boolean isTimerActive = false; + private static ArrayList runningAppProcessInfoList; + private static ProcessListenerMonitoring listener = null; + + public static boolean isProcessListenerActive() + { + return isMonitoringActive; + } + + private static Handler workHandler = new Handler() + { + @Override + public void handleMessage(Message msg) + { +// try +// { + Miscellaneous.logEvent("i", automationService.getResources().getString(R.string.processMonitoring), automationService.getResources().getString(R.string.messageReceivedStatingProcessMonitoringIsComplete), 5); + // This will take care of results delivered by the actual monitoring instance + + for(String entry : getRunningApps()) + Miscellaneous.logEvent("i", automationService.getResources().getString(R.string.runningApp), entry, 5); + + // execute matching rules containing processes + if(getRecentlyStartedApps().size()>0 | getRecentlyStoppedApps().size()>0) + { + for(String entry : getRecentlyStartedApps()) + Miscellaneous.logEvent("i", automationService.getResources().getString(R.string.appStarted), entry, 3); + for(String entry : getRecentlyStoppedApps()) + Miscellaneous.logEvent("i", automationService.getResources().getString(R.string.appStopped), entry, 3); + + ArrayList ruleCandidates = Rule.findRuleCandidatesByProcess(); + for(int i=0; ihandleMessage(): " + e.getMessage()); +// } + } + }; + + public static ArrayList getRunningApps() + { + if(runningAppsList1.size() == 0 && runningAppsList2.size() == 0) + ProcessListenerMonitoring.refreshRunningAppsList(); + + ArrayList runningAppsListReference; + + if(lastWritten == 1) + { + runningAppsListReference = runningAppsList1; + } + else + { + runningAppsListReference = runningAppsList2; + } + + return runningAppsListReference; + } + + public static ArrayList getRecentlyStartedApps() + { + ArrayList returnList = new ArrayList(); + + if(runCounter == 0) // Nothing ever happened. + return returnList; + + if(runCounter == 1) + // Only one run so far, all running apps are considered to have just started. + return runningAppsList1; + + ArrayList oldOne = null, newOne = null; + if(lastWritten == 1) + { + oldOne = runningAppsList2; + newOne = runningAppsList1; + } + else if(lastWritten == 2) + { + oldOne = runningAppsList1; + newOne = runningAppsList2; + } + + for(String runningApp : newOne) + { + if(!oldOne.contains(runningApp)) + //Started + returnList.add(runningApp); + } + + return returnList; + } + + public static ArrayList getRecentlyStoppedApps() + { + ArrayList returnList = new ArrayList(); + + if(runCounter == 1) // Nothing ever happened. + return returnList; + + if(runCounter == 1) + // Only one run so far, all running apps are considered to have just started, so return empty list. + return returnList; + + ArrayList oldOne = null, newOne = null; + if(lastWritten == 1) + { + oldOne = runningAppsList2; + newOne = runningAppsList1; + } + else if(lastWritten == 2) + { + oldOne = runningAppsList1; + newOne = runningAppsList2; + } + + for(String runningApp : oldOne) + { + if(!newOne.contains(runningApp)) + //Stopped + returnList.add(runningApp); + } + + return returnList; + } + + private static boolean stopRequested = false; + private static Handler schedulingHandler = new Handler() + { + @Override + public void handleMessage(Message msg) + { +// try +// { + if(msg.arg1 == 1) + { + if(!stopRequested) + { + listener = new ProcessListenerMonitoring(); + listener.doMonitoring(); + Miscellaneous.logEvent("i", automationService.getResources().getString(R.string.processMonitoring), automationService.getResources().getString(R.string.rearmingProcessMonitoringMessage), 5); + Message message = new Message(); + message.arg1 = 1; + schedulingHandler.sendMessageDelayed(message, Settings.timeBetweenProcessMonitorings * 1000); + } + else + Miscellaneous.logEvent("i", automationService.getResources().getString(R.string.processMonitoring), automationService.getResources().getString(R.string.notRearmingProcessMonitoringMessageStopRequested), 5); + } +// } +// catch(Exception e) +// { +// Miscellaneous.logEvent("e", "Noise level", "Error in schedulingHandler->handleMessage(): " + e.getMessage()); +// } + } + + }; + + private static class ProcessListenerMonitoring + { + Thread monitoringThread; + + public void doMonitoring() + { + monitoringThread = new Thread() + { + @Override + public void run() + { + if(!isMonitoringActive) + { + isMonitoringActive = true; + + Miscellaneous.logEvent("i", automationService.getResources().getString(R.string.processMonitoring), automationService.getResources().getString(R.string.periodicProcessMonitoringStarted), 5); + + refreshRunningAppsList(); + + Message answer = new Message(); +// Bundle answerBundle = new Bundle(); +// answer.setData(answerBundle); + workHandler.sendMessage(answer); + + //activate rule(s) + /*ArrayList ruleCandidates = Rule.findRuleCandidatesByProcess(); + for(int i=0; i services = activityManager.getRunningTasks(Integer.MAX_VALUE); + + ArrayList runningAppsListReference; + if(lastWritten == 1) + { +// Log.i("Processes", "Writing var 2"); + runningAppsListReference = runningAppsList2; + } + else + { +// Log.i("Processes", "Writing var 1"); + runningAppsListReference = runningAppsList1; + } + + runningAppsListReference.clear(); + + for (int i = 0; i < services.size(); i++) + { + if(!runningAppsListReference.contains(services.get(i).baseActivity.getClassName())) + { + // you may broadcast a new application launch here. + runningAppsListReference.add(services.get(i).baseActivity.getClassName()); + } + } + +// for(String runningApp : runningAppsListReference) +// { +// Miscellaneous.logEvent("i", "Running app", runningApp, 5); +// } + +// List procInfos = activityManager.getRunningAppProcesses(); +// for(int i = 0; i < procInfos.size(); i++) +// { +// ArrayList runningPkgs = new ArrayList(Arrays.asList(procInfos.get(i).pkgList)); +// +// Collection diff = subtractSets(runningPkgs, stalkList); +// +// if(diff != null) +// { +// stalkList.removeAll(diff); +// } +// } + + // Set marker to the one to be written next. + if(lastWritten == 1) + lastWritten = 2; + else if(lastWritten == 2) + lastWritten = 1; + else + lastWritten = -1; + + if(runCounter == 0 | runCounter == 1) + runCounter++; + } + + public void interrupt() + { + monitoringThread.interrupt(); + } + + private RunningAppProcessInfo getForegroundApp() + { + RunningAppProcessInfo result = null, info = null; + + final ActivityManager activityManager = (ActivityManager)automationService.getSystemService(Context.ACTIVITY_SERVICE); + + List l = activityManager.getRunningAppProcesses(); + Iterator i = l.iterator(); + while(i.hasNext()) + { + info = i.next(); + if(info.importance == RunningAppProcessInfo.IMPORTANCE_FOREGROUND + && !isRunningService(info.processName)) + { + result = info; + break; + } + } + return result; + } + + private boolean isRunningService(String processName) + { + if(processName == null) + return false; + + RunningServiceInfo service; + + final ActivityManager activityManager = (ActivityManager)automationService.getSystemService(Context.ACTIVITY_SERVICE); + + List l = activityManager.getRunningServices(9999); + Iterator i = l.iterator(); + while(i.hasNext()) + { + service = i.next(); + if(service.process.equals(processName)) + return true; + } + return false; + } + + private boolean isRunningApp(String processName) + { + if(processName == null) + return false; + + RunningAppProcessInfo app; + + final ActivityManager activityManager = (ActivityManager)automationService.getSystemService(Context.ACTIVITY_SERVICE); + + List l = activityManager.getRunningAppProcesses(); + Iterator i = l.iterator(); + while(i.hasNext()) + { + app = i.next(); + if(app.processName.equals(processName) && app.importance != RunningAppProcessInfo.IMPORTANCE_SERVICE) + return true; + } + return false; + } + + private boolean checkifThisIsActive(RunningAppProcessInfo target) + { + boolean result = false; + RunningTaskInfo info; + + if(target == null) + return false; + + final ActivityManager activityManager = (ActivityManager)automationService.getSystemService(Context.ACTIVITY_SERVICE); + + List l = activityManager.getRunningTasks(9999); + Iterator i = l.iterator(); + + while(i.hasNext()) + { + info=i.next(); + if(info.baseActivity.getPackageName().equals(target.processName)) + { + result = true; + break; + } + } + + return result; + } + + // what is in b that is not in a ? + public static Collection subtractSets(Collection a, Collection b) + { + Collection result = new ArrayList(b); + result.removeAll(a); + return result; + } + } + + public static void startProcessListener(AutomationService newAutomationService) + { + automationService = newAutomationService; + + if(!isTimerActive) + { + Miscellaneous.logEvent("i", automationService.getResources().getString(R.string.processMonitoring), automationService.getResources().getString(R.string.startingPeriodicProcessMonitoringEngine), 2); + isTimerActive = true; + + Message message = new Message(); + message.arg1 = 1; +// schedulingHandler.sendMessageDelayed(message, Settings.timeBetweenNoiseLevelMeasurements * 1000); + schedulingHandler.sendMessageDelayed(message, 10000); + } + else + Miscellaneous.logEvent("i", automationService.getResources().getString(R.string.processMonitoring), automationService.getResources().getString(R.string.periodicProcessMonitoringIsAlreadyRunning), 2); + } + public static void stopProcessListener(AutomationService newAutomationService) + { + if(isTimerActive) + { + stopRequested = true; + Miscellaneous.logEvent("i", automationService.getResources().getString(R.string.processMonitoring), automationService.getResources().getString(R.string.stoppingPeriodicProcessMonitoringEngine), 2); + + if(schedulingHandler.hasMessages(1)) + schedulingHandler.removeMessages(1); + + if(listener != null) + listener.interrupt(); + + isTimerActive = false; + } + else + { + automationService = newAutomationService; + Miscellaneous.logEvent("i", automationService.getResources().getString(R.string.processMonitoring), automationService.getResources().getString(R.string.periodicProcessMonitoringIsNotActive), 2); + } + } + + public static ArrayList getRunningAppProcessInfo() + { + return runningAppProcessInfoList; + } + + @Override + public void startListener(AutomationService automationService) + { + ProcessListener.startProcessListener(automationService); + } + + @Override + public void stopListener(AutomationService automationService) + { + ProcessListener.stopProcessListener(automationService); + } + + public static boolean haveAllPermission() + { + return ActivityPermissions.havePermission("android.permission.GET_TASKS", Miscellaneous.getAnyContext()); + } + + @Override + public boolean isListenerRunning() + { + return ProcessListener.isProcessListenerActive(); + } + + @Override + public Trigger_Enum[] getMonitoredTrigger() + { + return new Trigger_Enum[] { Trigger_Enum.process_started_stopped }; + } + + +} diff --git a/app/src/main/java/com/jens/automation2/receivers/StartupIntentReceiver.java b/app/src/main/java/com/jens/automation2/receivers/StartupIntentReceiver.java new file mode 100644 index 0000000..671714a --- /dev/null +++ b/app/src/main/java/com/jens/automation2/receivers/StartupIntentReceiver.java @@ -0,0 +1,34 @@ +package com.jens.automation2.receivers; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; + +import com.jens.automation2.AutomationService; +import com.jens.automation2.Miscellaneous; +import com.jens.automation2.R; +import com.jens.automation2.Settings; + +public class StartupIntentReceiver extends BroadcastReceiver +{ + + @Override + public void onReceive(Context context, Intent intent) + { + Settings.readFromPersistentStorage(context); + + Miscellaneous.logEvent("i", "Boot event", "Received event: " + intent.getAction(), 5); + + if(Settings.startServiceAtSystemBoot) + { + Miscellaneous.logEvent("i", "Service", context.getResources().getString(R.string.logStartingServiceAtPhoneBoot), 1); +// Settings.readFromPersistentStorage(context); + AutomationService.startAutomationService(context, true); + } + else + { + Miscellaneous.logEvent("i", "Service", context.getResources().getString(R.string.logNotStartingServiceAtPhoneBoot), 2); + } + } + +} diff --git a/app/src/main/java/com/jens/automation2/receivers/TimeZoneListener.java b/app/src/main/java/com/jens/automation2/receivers/TimeZoneListener.java new file mode 100644 index 0000000..c2856f2 --- /dev/null +++ b/app/src/main/java/com/jens/automation2/receivers/TimeZoneListener.java @@ -0,0 +1,114 @@ +package com.jens.automation2.receivers; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.util.Log; + +import com.jens.automation2.AutomationService; +import com.jens.automation2.Miscellaneous; +import com.jens.automation2.Rule; +import com.jens.automation2.Trigger.Trigger_Enum; + +public class TimeZoneListener extends BroadcastReceiver implements AutomationListenerInterface +{ + private static TimeZoneListener timeZoneListenerInstance = null; + protected static boolean timeZoneListenerActive = false; + protected static AutomationService automationServiceRef = null; + protected static IntentFilter timeZoneListenerIntentFilter = null; + + + public static boolean isTimeZoneListenerActive() + { + return timeZoneListenerActive; + } + + public static void startTimeZoneListener(AutomationService automationService) + { + if(timeZoneListenerInstance == null) + timeZoneListenerInstance = new TimeZoneListener(); + + automationServiceRef = automationService; + + try + { + if(!timeZoneListenerActive && Rule.isAnyRuleUsing(Trigger_Enum.timeFrame)) + { + Miscellaneous.logEvent("i", "TimeZoneListener", "Starting TimeZoneListener", 4); + timeZoneListenerActive = true; + + if(timeZoneListenerIntentFilter == null) + { + timeZoneListenerIntentFilter = new IntentFilter(); + timeZoneListenerIntentFilter.addAction(Intent.ACTION_TIMEZONE_CHANGED); + timeZoneListenerIntentFilter.addAction(Intent.ACTION_TIME_CHANGED); + } + + automationService.registerReceiver(timeZoneListenerInstance, timeZoneListenerIntentFilter); + } + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", "TimeZoneListener", "Error starting TimeZoneListener: " + Log.getStackTraceString(ex), 3); + } + } + public static void stopTimeZoneListener() + { + try + { + if(timeZoneListenerActive) + { + Miscellaneous.logEvent("i", "TimeZoneListener", "Stopping TimeZoneListener", 4); + automationServiceRef.unregisterReceiver(timeZoneListenerInstance); + timeZoneListenerActive = false; + } + } + catch(Exception ex) + { + Miscellaneous.logEvent("e", "TimeZoneListener", "Error stopping TimeZoneListener: " + Log.getStackTraceString(ex), 3); + } + } + + @Override + public void onReceive(Context context, Intent intent) + { + String action = intent.getAction(); + if(action.equals(Intent.ACTION_TIMEZONE_CHANGED)) + { + Miscellaneous.logEvent("i", "TimeZoneListener", "Device timezone changed. Reloading alarms.", 3); + AlarmListener.reloadAlarms(); + } + else if(action.equals(Intent.ACTION_TIME_CHANGED)) + { + Miscellaneous.logEvent("i", "TimeZoneListener", "Device time changed. Reloading alarms.", 4); + AlarmListener.reloadAlarms(); + } + } + @Override + public void startListener(AutomationService automationService) + { + TimeZoneListener.startTimeZoneListener(automationService); + } + @Override + public void stopListener(AutomationService automationService) + { + TimeZoneListener.stopTimeZoneListener(); + } + + public static boolean haveAllPermission() + { + return true; + } + + @Override + public boolean isListenerRunning() + { + return TimeZoneListener.isTimeZoneListenerActive(); + } + @Override + public Trigger_Enum[] getMonitoredTrigger() + { + return null; + } +} diff --git a/app/src/main/java/eu/chainfire/libsuperuser/Application.java b/app/src/main/java/eu/chainfire/libsuperuser/Application.java new file mode 100644 index 0000000..095c720 --- /dev/null +++ b/app/src/main/java/eu/chainfire/libsuperuser/Application.java @@ -0,0 +1,80 @@ +/* + * Copyright (C) 2012-2014 Jorrit "Chainfire" Jongma + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package eu.chainfire.libsuperuser; + +import android.content.Context; +import android.os.Handler; +import android.widget.Toast; + +/** + * Base application class to extend from, solving some issues with + * toasts and AsyncTasks you are likely to run into + */ +public class Application extends android.app.Application { + /** + * Shows a toast message + * + * @param context Any context belonging to this application + * @param message The message to show + */ + public static void toast(Context context, String message) { + // this is a static method so it is easier to call, + // as the context checking and casting is done for you + + if (context == null) return; + + if (!(context instanceof Application)) { + context = context.getApplicationContext(); + } + + if (context instanceof Application) { + final Context c = context; + final String m = message; + + ((Application)context).runInApplicationThread(new Runnable() { + @Override + public void run() { + Toast.makeText(c, m, Toast.LENGTH_LONG).show(); + } + }); + } + } + + private static Handler mApplicationHandler = new Handler(); + + /** + * Run a runnable in the main application thread + * + * @param r Runnable to run + */ + public void runInApplicationThread(Runnable r) { + mApplicationHandler.post(r); + } + + @Override + public void onCreate() { + super.onCreate(); + + try { + // workaround bug in AsyncTask, can show up (for example) when you toast from a service + // this makes sure AsyncTask's internal handler is created from the right (main) thread + Class.forName("android.os.AsyncTask"); + } catch (ClassNotFoundException e) { + // will never happen + } + } +} diff --git a/app/src/main/java/eu/chainfire/libsuperuser/Debug.java b/app/src/main/java/eu/chainfire/libsuperuser/Debug.java new file mode 100644 index 0000000..4ad0718 --- /dev/null +++ b/app/src/main/java/eu/chainfire/libsuperuser/Debug.java @@ -0,0 +1,242 @@ +/* + * Copyright (C) 2012-2014 Jorrit "Chainfire" Jongma + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package eu.chainfire.libsuperuser; + +import android.os.Looper; +import android.util.Log; + +import com.jens.automation2.BuildConfig; + +/** + * Utility class for logging and debug features that (by default) does nothing when not in debug mode + */ +public class Debug { + + // ----- DEBUGGING ----- + + private static boolean debug = BuildConfig.DEBUG; + + /** + *

Enable or disable debug mode

+ * + *

By default, debug mode is enabled for development + * builds and disabled for exported APKs - see + * BuildConfig.DEBUG

+ * + * @param enable Enable debug mode ? + */ + public static void setDebug(boolean enable) { + debug = enable; + } + + /** + *

Is debug mode enabled ?

+ * + * @return Debug mode enabled + */ + public static boolean getDebug() { + return debug; + } + + // ----- LOGGING ----- + + public interface OnLogListener { + void onLog(int type, String typeIndicator, String message); + } + + public static final String TAG = "libsuperuser"; + + public static final int LOG_GENERAL = 0x0001; + public static final int LOG_COMMAND = 0x0002; + public static final int LOG_OUTPUT = 0x0004; + + public static final int LOG_NONE = 0x0000; + public static final int LOG_ALL = 0xFFFF; + + private static int logTypes = LOG_ALL; + + private static OnLogListener logListener = null; + + /** + *

Log a message (internal)

+ * + *

Current debug and enabled logtypes decide what gets logged - + * even if a custom callback is registered

+ * + * @param type Type of message to log + * @param typeIndicator String indicator for message type + * @param message The message to log + */ + private static void logCommon(int type, String typeIndicator, String message) { + if (debug && ((logTypes & type) == type)) { + if (logListener != null) { + logListener.onLog(type, typeIndicator, message); + } else { + Log.d(TAG, "[" + TAG + "][" + typeIndicator + "]" + (!message.startsWith("[") && !message.startsWith(" ") ? " " : "") + message); + } + } + } + + /** + *

Log a "general" message

+ * + *

These messages are infrequent and mostly occur at startup/shutdown or on error

+ * + * @param message The message to log + */ + public static void log(String message) { + logCommon(LOG_GENERAL, "G", message); + } + + /** + *

Log a "per-command" message

+ * + *

This could produce a lot of output if the client runs many commands in the session

+ * + * @param message The message to log + */ + public static void logCommand(String message) { + logCommon(LOG_COMMAND, "C", message); + } + + /** + *

Log a line of stdout/stderr output

+ * + *

This could produce a lot of output if the shell commands are noisy

+ * + * @param message The message to log + */ + public static void logOutput(String message) { + logCommon(LOG_OUTPUT, "O", message); + } + + /** + *

Enable or disable logging specific types of message

+ * + *

You may | (or) LOG_* constants together. Note that + * debug mode must also be enabled for actual logging to + * occur.

+ * + * @param type LOG_* constants + * @param enable Enable or disable + */ + public static void setLogTypeEnabled(int type, boolean enable) { + if (enable) { + logTypes |= type; + } else { + logTypes &= ~type; + } + } + + /** + *

Is logging for specific types of messages enabled ?

+ * + *

You may | (or) LOG_* constants together, to learn if + * all passed message types are enabled for logging. Note + * that debug mode must also be enabled for actual logging + * to occur.

+ * + * @param type LOG_* constants + */ + public static boolean getLogTypeEnabled(int type) { + return ((logTypes & type) == type); + } + + /** + *

Is logging for specific types of messages enabled ?

+ * + *

You may | (or) LOG_* constants together, to learn if + * all message types are enabled for logging. Takes + * debug mode into account for the result.

+ * + * @param type LOG_* constants + */ + public static boolean getLogTypeEnabledEffective(int type) { + return getDebug() && getLogTypeEnabled(type); + } + + /** + *

Register a custom log handler

+ * + *

Replaces the log method (write to logcat) with your own + * handler. Whether your handler gets called is still dependent + * on debug mode and message types being enabled for logging.

+ * + * @param onLogListener Custom log listener or NULL to revert to default + */ + public static void setOnLogListener(OnLogListener onLogListener) { + logListener = onLogListener; + } + + /** + *

Get the currently registered custom log handler

+ * + * @return Current custom log handler or NULL if none is present + */ + public static OnLogListener getOnLogListener() { + return logListener; + } + + // ----- SANITY CHECKS ----- + + private static boolean sanityChecks = true; + + /** + *

Enable or disable sanity checks

+ * + *

Enables or disables the library crashing when su is called + * from the main thread.

+ * + * @param enable Enable or disable + */ + public static void setSanityChecksEnabled(boolean enable) { + sanityChecks = enable; + } + + /** + *

Are sanity checks enabled ?

+ * + *

Note that debug mode must also be enabled for actual + * sanity checks to occur.

+ * + * @return True if enabled + */ + public static boolean getSanityChecksEnabled() { + return sanityChecks; + } + + /** + *

Are sanity checks enabled ?

+ * + *

Takes debug mode into account for the result.

+ * + * @return True if enabled + */ + public static boolean getSanityChecksEnabledEffective() { + return getDebug() && getSanityChecksEnabled(); + } + + /** + *

Are we running on the main thread ?

+ * + * @return Running on main thread ? + */ + public static boolean onMainThread() { + return ((Looper.myLooper() != null) && (Looper.myLooper() == Looper.getMainLooper())); + } + +} diff --git a/app/src/main/java/eu/chainfire/libsuperuser/HideOverlaysReceiver.java b/app/src/main/java/eu/chainfire/libsuperuser/HideOverlaysReceiver.java new file mode 100644 index 0000000..4b4ce5a --- /dev/null +++ b/app/src/main/java/eu/chainfire/libsuperuser/HideOverlaysReceiver.java @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2012-2014 Jorrit "Chainfire" Jongma + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package eu.chainfire.libsuperuser; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; + +/** + *

+ * Base receiver to extend to catch notifications when overlays should be + * hidden. + *

+ *

+ * Tapjacking protection in SuperSU prevents some dialogs from receiving user + * input when overlays are present. For security reasons this notification is + * only sent to apps that have previously been granted root access, so even if + * your app does not require root, you still need to request + * it, and the user must grant it. + *

+ *

+ * Note that the word overlay as used here should be interpreted as "any view or + * window possibly obscuring SuperSU dialogs". + *

+ */ +public abstract class HideOverlaysReceiver extends BroadcastReceiver { + public static final String ACTION_HIDE_OVERLAYS = "eu.chainfire.supersu.action.HIDE_OVERLAYS"; + public static final String CATEGORY_HIDE_OVERLAYS = Intent.CATEGORY_INFO; + public static final String EXTRA_HIDE_OVERLAYS = "eu.chainfire.supersu.extra.HIDE"; + + @Override + public final void onReceive(Context context, Intent intent) { + if (intent.hasExtra(EXTRA_HIDE_OVERLAYS)) { + onHideOverlays(intent.getBooleanExtra(EXTRA_HIDE_OVERLAYS, false)); + } + } + + /** + * Called when overlays should be hidden or may be shown + * again. + * + * @param hide Should overlays be hidden? + */ + public abstract void onHideOverlays(boolean hide); +} diff --git a/app/src/main/java/eu/chainfire/libsuperuser/Shell.java b/app/src/main/java/eu/chainfire/libsuperuser/Shell.java new file mode 100644 index 0000000..2c2386d --- /dev/null +++ b/app/src/main/java/eu/chainfire/libsuperuser/Shell.java @@ -0,0 +1,1757 @@ +/* + * Copyright (C) 2012-2014 Jorrit "Chainfire" Jongma + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package eu.chainfire.libsuperuser; + +import android.os.Handler; +import android.os.Looper; + +import java.io.DataOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.UUID; +import java.util.concurrent.ScheduledThreadPoolExecutor; +import java.util.concurrent.TimeUnit; + +import eu.chainfire.libsuperuser.StreamGobbler.OnLineListener; + +/** + * Class providing functionality to execute commands in a (root) shell + */ +public class Shell { + /** + *

+ * Runs commands using the supplied shell, and returns the output, or null + * in case of errors. + *

+ *

+ * This method is deprecated and only provided for backwards compatibility. + * Use {@link #run(String, String[], String[], boolean)} instead, and see + * that same method for usage notes. + *

+ * + * @param shell The shell to use for executing the commands + * @param commands The commands to execute + * @param wantSTDERR Return STDERR in the output ? + * @return Output of the commands, or null in case of an error + */ + @Deprecated + public static List run(String shell, String[] commands, boolean wantSTDERR) { + return run(shell, commands, null, wantSTDERR); + } + + /** + *

+ * Runs commands using the supplied shell, and returns the output, or null + * in case of errors. + *

+ *

+ * Note that due to compatibility with older Android versions, wantSTDERR is + * not implemented using redirectErrorStream, but rather appended to the + * output. STDOUT and STDERR are thus not guaranteed to be in the correct + * order in the output. + *

+ *

+ * Note as well that this code will intentionally crash when run in debug + * mode from the main thread of the application. You should always execute + * shell commands from a background thread. + *

+ *

+ * When in debug mode, the code will also excessively log the commands + * passed to and the output returned from the shell. + *

+ *

+ * Though this function uses background threads to gobble STDOUT and STDERR + * so a deadlock does not occur if the shell produces massive output, the + * output is still stored in a List<String>, and as such doing + * something like 'ls -lR /' will probably have you run out of + * memory. + *

+ * + * @param shell The shell to use for executing the commands + * @param commands The commands to execute + * @param environment List of all environment variables (in 'key=value' + * format) or null for defaults + * @param wantSTDERR Return STDERR in the output ? + * @return Output of the commands, or null in case of an error + */ + public static List run(String shell, String[] commands, String[] environment, + boolean wantSTDERR) { + String shellUpper = shell.toUpperCase(Locale.ENGLISH); + + if (Debug.getSanityChecksEnabledEffective() && Debug.onMainThread()) { + // check if we're running in the main thread, and if so, crash if + // we're in debug mode, to let the developer know attention is + // needed here. + + Debug.log(ShellOnMainThreadException.EXCEPTION_COMMAND); + throw new ShellOnMainThreadException(ShellOnMainThreadException.EXCEPTION_COMMAND); + } + Debug.logCommand(String.format("[%s%%] START", shellUpper)); + + List res = Collections.synchronizedList(new ArrayList()); + + try { + // Combine passed environment with system environment + if (environment != null) { + Map newEnvironment = new HashMap(); + newEnvironment.putAll(System.getenv()); + int split; + for (String entry : environment) { + if ((split = entry.indexOf("=")) >= 0) { + newEnvironment.put(entry.substring(0, split), entry.substring(split + 1)); + } + } + int i = 0; + environment = new String[newEnvironment.size()]; + for (Map.Entry entry : newEnvironment.entrySet()) { + environment[i] = entry.getKey() + "=" + entry.getValue(); + i++; + } + } + + // setup our process, retrieve STDIN stream, and STDOUT/STDERR + // gobblers + Process process = Runtime.getRuntime().exec(shell, environment); + DataOutputStream STDIN = new DataOutputStream(process.getOutputStream()); + StreamGobbler STDOUT = new StreamGobbler(shellUpper + "-", process.getInputStream(), + res); + StreamGobbler STDERR = new StreamGobbler(shellUpper + "*", process.getErrorStream(), + wantSTDERR ? res : null); + + // start gobbling and write our commands to the shell + STDOUT.start(); + STDERR.start(); + try { + for (String write : commands) { + Debug.logCommand(String.format("[%s+] %s", shellUpper, write)); + STDIN.write((write + "\n").getBytes("UTF-8")); + STDIN.flush(); + } + STDIN.write("exit\n".getBytes("UTF-8")); + STDIN.flush(); + } catch (IOException e) { + if (e.getMessage().contains("EPIPE")) { + // method most horrid to catch broken pipe, in which case we + // do nothing. the command is not a shell, the shell closed + // STDIN, the script already contained the exit command, etc. + // these cases we want the output instead of returning null + } else { + // other issues we don't know how to handle, leads to + // returning null + throw e; + } + } + + // wait for our process to finish, while we gobble away in the + // background + process.waitFor(); + + // make sure our threads are done gobbling, our streams are closed, + // and the process is destroyed - while the latter two shouldn't be + // needed in theory, and may even produce warnings, in "normal" Java + // they are required for guaranteed cleanup of resources, so lets be + // safe and do this on Android as well + try { + STDIN.close(); + } catch (IOException e) { + // might be closed already + } + STDOUT.join(); + STDERR.join(); + process.destroy(); + + // in case of su, 255 usually indicates access denied + if (SU.isSU(shell) && (process.exitValue() == 255)) { + res = null; + } + } catch (IOException e) { + // shell probably not found + res = null; + } catch (InterruptedException e) { + // this should really be re-thrown + res = null; + } + + Debug.logCommand(String.format("[%s%%] END", shell.toUpperCase(Locale.ENGLISH))); + return res; + } + + protected static String[] availableTestCommands = new String[] { + "echo -BOC-", + "id" + }; + + /** + * See if the shell is alive, and if so, check the UID + * + * @param ret Standard output from running availableTestCommands + * @param checkForRoot true if we are expecting this shell to be running as + * root + * @return true on success, false on error + */ + protected static boolean parseAvailableResult(List ret, boolean checkForRoot) { + if (ret == null) + return false; + + // this is only one of many ways this can be done + boolean echo_seen = false; + + for (String line : ret) { + if (line.contains("uid=")) { + // id command is working, let's see if we are actually root + return !checkForRoot || line.contains("uid=0"); + } else if (line.contains("-BOC-")) { + // if we end up here, at least the su command starts some kind + // of shell, + // let's hope it has root privileges - no way to know without + // additional + // native binaries + echo_seen = true; + } + } + + return echo_seen; + } + + /** + * This class provides utility functions to easily execute commands using SH + */ + public static class SH { + /** + * Runs command and return output + * + * @param command The command to run + * @return Output of the command, or null in case of an error + */ + public static List run(String command) { + return Shell.run("sh", new String[] { + command + }, null, false); + } + + /** + * Runs commands and return output + * + * @param commands The commands to run + * @return Output of the commands, or null in case of an error + */ + public static List run(List commands) { + return Shell.run("sh", commands.toArray(new String[commands.size()]), null, false); + } + + /** + * Runs commands and return output + * + * @param commands The commands to run + * @return Output of the commands, or null in case of an error + */ + public static List run(String[] commands) { + return Shell.run("sh", commands, null, false); + } + } + + /** + * This class provides utility functions to easily execute commands using SU + * (root shell), as well as detecting whether or not root is available, and + * if so which version. + */ + public static class SU { + private static Boolean isSELinuxEnforcing = null; + private static String[] suVersion = new String[] { + null, null + }; + + /** + * Runs command as root (if available) and return output + * + * @param command The command to run + * @return Output of the command, or null if root isn't available or in + * case of an error + */ + public static List run(String command) { + return Shell.run("su", new String[] { + command + }, null, false); + } + + /** + * Runs commands as root (if available) and return output + * + * @param commands The commands to run + * @return Output of the commands, or null if root isn't available or in + * case of an error + */ + public static List run(List commands) { + return Shell.run("su", commands.toArray(new String[commands.size()]), null, false); + } + + /** + * Runs commands as root (if available) and return output + * + * @param commands The commands to run + * @return Output of the commands, or null if root isn't available or in + * case of an error + */ + public static List run(String[] commands) { + return Shell.run("su", commands, null, false); + } + + /** + * Detects whether or not superuser access is available, by checking the + * output of the "id" command if available, checking if a shell runs at + * all otherwise + * + * @return True if superuser access available + */ + public static boolean available() { + // this is only one of many ways this can be done + + List ret = run(Shell.availableTestCommands); + return Shell.parseAvailableResult(ret, true); + } + + /** + *

+ * Detects the version of the su binary installed (if any), if supported + * by the binary. Most binaries support two different version numbers, + * the public version that is displayed to users, and an internal + * version number that is used for version number comparisons. Returns + * null if su not available or retrieving the version isn't supported. + *

+ *

+ * Note that su binary version and GUI (APK) version can be completely + * different. + *

+ *

+ * This function caches its result to improve performance on multiple + * calls + *

+ * + * @param internal Request human-readable version or application + * internal version + * @return String containing the su version or null + */ + public static synchronized String version(boolean internal) { + int idx = internal ? 0 : 1; + if (suVersion[idx] == null) { + String version = null; + + List ret = Shell.run( + internal ? "su -V" : "su -v", + new String[] { "exit" }, + null, + false + ); + + if (ret != null) { + for (String line : ret) { + if (!internal) { + if (!line.trim().equals("")) { + version = line; + break; + } + } else { + try { + if (Integer.parseInt(line) > 0) { + version = line; + break; + } + } catch (NumberFormatException e) { + // should be parsable, try next line otherwise + } + } + } + } + + suVersion[idx] = version; + } + return suVersion[idx]; + } + + /** + * Attempts to deduce if the shell command refers to a su shell + * + * @param shell Shell command to run + * @return Shell command appears to be su + */ + public static boolean isSU(String shell) { + // Strip parameters + int pos = shell.indexOf(' '); + if (pos >= 0) { + shell = shell.substring(0, pos); + } + + // Strip path + pos = shell.lastIndexOf('/'); + if (pos >= 0) { + shell = shell.substring(pos + 1); + } + + return shell.equals("su"); + } + + /** + * Constructs a shell command to start a su shell using the supplied uid + * and SELinux context. This is can be an expensive operation, consider + * caching the result. + * + * @param uid Uid to use (0 == root) + * @param context (SELinux) context name to use or null + * @return Shell command + */ + public static String shell(int uid, String context) { + // su[ --context ][ ] + String shell = "su"; + + if ((context != null) && isSELinuxEnforcing()) { + String display = version(false); + String internal = version(true); + + // We only know the format for SuperSU v1.90+ right now + if ((display != null) && + (internal != null) && + (display.endsWith("SUPERSU")) && + (Integer.valueOf(internal) >= 190)) { + shell = String.format(Locale.ENGLISH, "%s --context %s", shell, context); + } + } + + // Most su binaries support the "su " format, but in case + // they don't, lets skip it for the default 0 (root) case + if (uid > 0) { + shell = String.format(Locale.ENGLISH, "%s %d", shell, uid); + } + + return shell; + } + + /** + * Constructs a shell command to start a su shell connected to mount + * master daemon, to perform public mounts on Android 4.3+ (or 4.2+ in + * SELinux enforcing mode) + * + * @return Shell command + */ + public static String shellMountMaster() { + if (android.os.Build.VERSION.SDK_INT >= 17) { + return "su --mount-master"; + } + return "su"; + } + + /** + * Detect if SELinux is set to enforcing, caches result + * + * @return true if SELinux set to enforcing, or false in the case of + * permissive or not present + */ + public static synchronized boolean isSELinuxEnforcing() { + if (isSELinuxEnforcing == null) { + Boolean enforcing = null; + + // First known firmware with SELinux built-in was a 4.2 (17) + // leak + if (android.os.Build.VERSION.SDK_INT >= 17) { + // Detect enforcing through sysfs, not always present + File f = new File("/sys/fs/selinux/enforce"); + if (f.exists()) { + try { + InputStream is = new FileInputStream("/sys/fs/selinux/enforce"); + try { + enforcing = (is.read() == '1'); + } finally { + is.close(); + } + } catch (Exception e) { + // we might not be allowed to read, thanks SELinux + } + } + + // 4.4+ builds are enforcing by default, take the gamble + if (enforcing == null) { + enforcing = (android.os.Build.VERSION.SDK_INT >= 19); + } + } + + if (enforcing == null) { + enforcing = false; + } + + isSELinuxEnforcing = enforcing; + } + return isSELinuxEnforcing; + } + + /** + *

+ * Clears results cached by isSELinuxEnforcing() and version(boolean + * internal) calls. + *

+ *

+ * Most apps should never need to call this, as neither enforcing status + * nor su version is likely to change on a running device - though it is + * not impossible. + *

+ */ + public static synchronized void clearCachedResults() { + isSELinuxEnforcing = null; + suVersion[0] = null; + suVersion[1] = null; + } + } + + private interface OnResult { + // for any onCommandResult callback + int WATCHDOG_EXIT = -1; + int SHELL_DIED = -2; + + // for Interactive.open() callbacks only + int SHELL_EXEC_FAILED = -3; + int SHELL_WRONG_UID = -4; + int SHELL_RUNNING = 0; + } + + /** + * Command result callback, notifies the recipient of the completion of a + * command block, including the (last) exit code, and the full output + */ + public interface OnCommandResultListener extends OnResult { + /** + *

+ * Command result callback + *

+ *

+ * Depending on how and on which thread the shell was created, this + * callback may be executed on one of the gobbler threads. In that case, + * it is important the callback returns as quickly as possible, as + * delays in this callback may pause the native process or even result + * in a deadlock + *

+ *

+ * See {@link Interactive} for threading details + *

+ * + * @param commandCode Value previously supplied to addCommand + * @param exitCode Exit code of the last command in the block + * @param output All output generated by the command block + */ + void onCommandResult(int commandCode, int exitCode, List output); + } + + /** + * Command per line callback for parsing the output line by line without + * buffering It also notifies the recipient of the completion of a command + * block, including the (last) exit code. + */ + public interface OnCommandLineListener extends OnResult, OnLineListener + { + /** + *

+ * Command result callback + *

+ *

+ * Depending on how and on which thread the shell was created, this + * callback may be executed on one of the gobbler threads. In that case, + * it is important the callback returns as quickly as possible, as + * delays in this callback may pause the native process or even result + * in a deadlock + *

+ *

+ * See {@link Interactive} for threading details + *

+ * + * @param commandCode Value previously supplied to addCommand + * @param exitCode Exit code of the last command in the block + */ + void onCommandResult(int commandCode, int exitCode); + } + + /** + * Internal class to store command block properties + */ + private static class Command { + private static int commandCounter = 0; + + private final String[] commands; + private final int code; + private final OnCommandResultListener onCommandResultListener; + private final OnCommandLineListener onCommandLineListener; + private final String marker; + + public Command(String[] commands, int code, + OnCommandResultListener onCommandResultListener, + OnCommandLineListener onCommandLineListener) { + this.commands = commands; + this.code = code; + this.onCommandResultListener = onCommandResultListener; + this.onCommandLineListener = onCommandLineListener; + this.marker = UUID.randomUUID().toString() + String.format("-%08x", ++commandCounter); + } + } + + /** + * Builder class for {@link Interactive} + */ + public static class Builder { + private Handler handler = null; + private boolean autoHandler = true; + private String shell = "sh"; + private boolean wantSTDERR = false; + private List commands = new LinkedList(); + private Map environment = new HashMap(); + private OnLineListener onSTDOUTLineListener = null; + private OnLineListener onSTDERRLineListener = null; + private int watchdogTimeout = 0; + + /** + *

+ * Set a custom handler that will be used to post all callbacks to + *

+ *

+ * See {@link Interactive} for further details on threading and + * handlers + *

+ * + * @param handler Handler to use + * @return This Builder object for method chaining + */ + public Builder setHandler(Handler handler) { + this.handler = handler; + return this; + } + + /** + *

+ * Automatically create a handler if possible ? Default to true + *

+ *

+ * See {@link Interactive} for further details on threading and + * handlers + *

+ * + * @param autoHandler Auto-create handler ? + * @return This Builder object for method chaining + */ + public Builder setAutoHandler(boolean autoHandler) { + this.autoHandler = autoHandler; + return this; + } + + /** + * Set shell binary to use. Usually "sh" or "su", do not use a full path + * unless you have a good reason to + * + * @param shell Shell to use + * @return This Builder object for method chaining + */ + public Builder setShell(String shell) { + this.shell = shell; + return this; + } + + /** + * Convenience function to set "sh" as used shell + * + * @return This Builder object for method chaining + */ + public Builder useSH() { + return setShell("sh"); + } + + /** + * Convenience function to set "su" as used shell + * + * @return This Builder object for method chaining + */ + public Builder useSU() { + return setShell("su"); + } + + /** + * Set if error output should be appended to command block result output + * + * @param wantSTDERR Want error output ? + * @return This Builder object for method chaining + */ + public Builder setWantSTDERR(boolean wantSTDERR) { + this.wantSTDERR = wantSTDERR; + return this; + } + + /** + * Add or update an environment variable + * + * @param key Key of the environment variable + * @param value Value of the environment variable + * @return This Builder object for method chaining + */ + public Builder addEnvironment(String key, String value) { + environment.put(key, value); + return this; + } + + /** + * Add or update environment variables + * + * @param addEnvironment Map of environment variables + * @return This Builder object for method chaining + */ + public Builder addEnvironment(Map addEnvironment) { + environment.putAll(addEnvironment); + return this; + } + + /** + * Add a command to execute + * + * @param command Command to execute + * @return This Builder object for method chaining + */ + public Builder addCommand(String command) { + return addCommand(command, 0, null); + } + + /** + *

+ * Add a command to execute, with a callback to be called on completion + *

+ *

+ * The thread on which the callback executes is dependent on various + * factors, see {@link Interactive} for further details + *

+ * + * @param command Command to execute + * @param code User-defined value passed back to the callback + * @param onCommandResultListener Callback to be called on completion + * @return This Builder object for method chaining + */ + public Builder addCommand(String command, int code, + OnCommandResultListener onCommandResultListener) { + return addCommand(new String[] { + command + }, code, onCommandResultListener); + } + + /** + * Add commands to execute + * + * @param commands Commands to execute + * @return This Builder object for method chaining + */ + public Builder addCommand(List commands) { + return addCommand(commands, 0, null); + } + + /** + *

+ * Add commands to execute, with a callback to be called on completion + * (of all commands) + *

+ *

+ * The thread on which the callback executes is dependent on various + * factors, see {@link Interactive} for further details + *

+ * + * @param commands Commands to execute + * @param code User-defined value passed back to the callback + * @param onCommandResultListener Callback to be called on completion + * (of all commands) + * @return This Builder object for method chaining + */ + public Builder addCommand(List commands, int code, + OnCommandResultListener onCommandResultListener) { + return addCommand(commands.toArray(new String[commands.size()]), code, + onCommandResultListener); + } + + /** + * Add commands to execute + * + * @param commands Commands to execute + * @return This Builder object for method chaining + */ + public Builder addCommand(String[] commands) { + return addCommand(commands, 0, null); + } + + /** + *

+ * Add commands to execute, with a callback to be called on completion + * (of all commands) + *

+ *

+ * The thread on which the callback executes is dependent on various + * factors, see {@link Interactive} for further details + *

+ * + * @param commands Commands to execute + * @param code User-defined value passed back to the callback + * @param onCommandResultListener Callback to be called on completion + * (of all commands) + * @return This Builder object for method chaining + */ + public Builder addCommand(String[] commands, int code, + OnCommandResultListener onCommandResultListener) { + this.commands.add(new Command(commands, code, onCommandResultListener, null)); + return this; + } + + /** + *

+ * Set a callback called for every line output to STDOUT by the shell + *

+ *

+ * The thread on which the callback executes is dependent on various + * factors, see {@link Interactive} for further details + *

+ * + * @param onLineListener Callback to be called for each line + * @return This Builder object for method chaining + */ + public Builder setOnSTDOUTLineListener(OnLineListener onLineListener) { + this.onSTDOUTLineListener = onLineListener; + return this; + } + + /** + *

+ * Set a callback called for every line output to STDERR by the shell + *

+ *

+ * The thread on which the callback executes is dependent on various + * factors, see {@link Interactive} for further details + *

+ * + * @param onLineListener Callback to be called for each line + * @return This Builder object for method chaining + */ + public Builder setOnSTDERRLineListener(OnLineListener onLineListener) { + this.onSTDERRLineListener = onLineListener; + return this; + } + + /** + *

+ * Enable command timeout callback + *

+ *

+ * This will invoke the onCommandResult() callback with exitCode + * WATCHDOG_EXIT if a command takes longer than watchdogTimeout seconds + * to complete. + *

+ *

+ * If a watchdog timeout occurs, it generally means that the Interactive + * session is out of sync with the shell process. The caller should + * close the current session and open a new one. + *

+ * + * @param watchdogTimeout Timeout, in seconds; 0 to disable + * @return This Builder object for method chaining + */ + public Builder setWatchdogTimeout(int watchdogTimeout) { + this.watchdogTimeout = watchdogTimeout; + return this; + } + + /** + *

+ * Enable/disable reduced logcat output + *

+ *

+ * Note that this is a global setting + *

+ * + * @param useMinimal true for reduced output, false for full output + * @return This Builder object for method chaining + */ + public Builder setMinimalLogging(boolean useMinimal) { + Debug.setLogTypeEnabled(Debug.LOG_COMMAND | Debug.LOG_OUTPUT, !useMinimal); + return this; + } + + /** + * Construct a {@link Interactive} instance, and start the shell + */ + public Interactive open() { + return new Interactive(this, null); + } + + /** + * Construct a {@link Interactive} instance, try to start the + * shell, and call onCommandResultListener to report success or failure + * + * @param onCommandResultListener Callback to return shell open status + */ + public Interactive open(OnCommandResultListener onCommandResultListener) { + return new Interactive(this, onCommandResultListener); + } + } + + /** + *

+ * An interactive shell - initially created with {@link Builder} - + * that executes blocks of commands you supply in the background, optionally + * calling callbacks as each block completes. + *

+ *

+ * STDERR output can be supplied as well, but due to compatibility with + * older Android versions, wantSTDERR is not implemented using + * redirectErrorStream, but rather appended to the output. STDOUT and STDERR + * are thus not guaranteed to be in the correct order in the output. + *

+ *

+ * Note as well that the close() and waitForIdle() methods will + * intentionally crash when run in debug mode from the main thread of the + * application. Any blocking call should be run from a background thread. + *

+ *

+ * When in debug mode, the code will also excessively log the commands + * passed to and the output returned from the shell. + *

+ *

+ * Though this function uses background threads to gobble STDOUT and STDERR + * so a deadlock does not occur if the shell produces massive output, the + * output is still stored in a List<String>, and as such doing + * something like 'ls -lR /' will probably have you run out of + * memory when using a {@link OnCommandResultListener}. A work-around + * is to not supply this callback, but using (only) + * {@link Builder#setOnSTDOUTLineListener(OnLineListener)}. This way, + * an internal buffer will not be created and wasting your memory. + *

+ *

Callbacks, threads and handlers

+ *

+ * On which thread the callbacks execute is dependent on your + * initialization. You can supply a custom Handler using + * {@link Builder#setHandler(Handler)} if needed. If you do not supply + * a custom Handler - unless you set + * {@link Builder#setAutoHandler(boolean)} to false - a Handler will + * be auto-created if the thread used for instantiation of the object has a + * Looper. + *

+ *

+ * If no Handler was supplied and it was also not auto-created, all + * callbacks will be called from either the STDOUT or STDERR gobbler + * threads. These are important threads that should be blocked as little as + * possible, as blocking them may in rare cases pause the native process or + * even create a deadlock. + *

+ *

+ * The main thread must certainly have a Looper, thus if you call + * {@link Builder#open()} from the main thread, a handler will (by + * default) be auto-created, and all the callbacks will be called on the + * main thread. While this is often convenient and easy to code with, you + * should be aware that if your callbacks are 'expensive' to execute, this + * may negatively impact UI performance. + *

+ *

+ * Background threads usually do not have a Looper, so calling + * {@link Builder#open()} from such a background thread will (by + * default) result in all the callbacks being executed in one of the gobbler + * threads. You will have to make sure the code you execute in these + * callbacks is thread-safe. + *

+ */ + public static class Interactive { + private final Handler handler; + private final boolean autoHandler; + private final String shell; + private final boolean wantSTDERR; + private final List commands; + private final Map environment; + private final OnLineListener onSTDOUTLineListener; + private final OnLineListener onSTDERRLineListener; + private int watchdogTimeout; + + private Process process = null; + private DataOutputStream STDIN = null; + private StreamGobbler STDOUT = null; + private StreamGobbler STDERR = null; + private ScheduledThreadPoolExecutor watchdog = null; + + private volatile boolean running = false; + private volatile boolean idle = true; // read/write only synchronized + private volatile boolean closed = true; + private volatile int callbacks = 0; + private volatile int watchdogCount; + + private final Object idleSync = new Object(); + private final Object callbackSync = new Object(); + + private volatile int lastExitCode = 0; + private volatile String lastMarkerSTDOUT = null; + private volatile String lastMarkerSTDERR = null; + private volatile Command command = null; + private volatile List buffer = null; + + /** + * The only way to create an instance: Shell.Builder::open() + * + * @param builder Builder class to take values from + */ + private Interactive(final Builder builder, + final OnCommandResultListener onCommandResultListener) { + autoHandler = builder.autoHandler; + shell = builder.shell; + wantSTDERR = builder.wantSTDERR; + commands = builder.commands; + environment = builder.environment; + onSTDOUTLineListener = builder.onSTDOUTLineListener; + onSTDERRLineListener = builder.onSTDERRLineListener; + watchdogTimeout = builder.watchdogTimeout; + + // If a looper is available, we offload the callbacks from the + // gobbling threads + // to whichever thread created us. Would normally do this in open(), + // but then we could not declare handler as final + if ((Looper.myLooper() != null) && (builder.handler == null) && autoHandler) { + handler = new Handler(); + } else { + handler = builder.handler; + } + + if (onCommandResultListener != null) { + // Allow up to 60 seconds for SuperSU/Superuser dialog, then enable + // the user-specified timeout for all subsequent operations + watchdogTimeout = 60; + commands.add(0, new Command(Shell.availableTestCommands, 0, new OnCommandResultListener() { + public void onCommandResult(int commandCode, int exitCode, List output) { + if ((exitCode == OnCommandResultListener.SHELL_RUNNING) && + !Shell.parseAvailableResult(output, SU.isSU(shell))) { + // shell is up, but it's brain-damaged + exitCode = OnCommandResultListener.SHELL_WRONG_UID; + } + watchdogTimeout = builder.watchdogTimeout; + onCommandResultListener.onCommandResult(0, exitCode, output); + } + }, null)); + } + + if (!open() && (onCommandResultListener != null)) { + onCommandResultListener.onCommandResult(0, + OnCommandResultListener.SHELL_EXEC_FAILED, null); + } + } + + @Override + protected void finalize() throws Throwable { + if (!closed && Debug.getSanityChecksEnabledEffective()) { + // waste of resources + Debug.log(ShellNotClosedException.EXCEPTION_NOT_CLOSED); + throw new ShellNotClosedException(); + } + super.finalize(); + } + + /** + * Add a command to execute + * + * @param command Command to execute + */ + public void addCommand(String command) { + addCommand(command, 0, (OnCommandResultListener) null); + } + + /** + *

+ * Add a command to execute, with a callback to be called on completion + *

+ *

+ * The thread on which the callback executes is dependent on various + * factors, see {@link Interactive} for further details + *

+ * + * @param command Command to execute + * @param code User-defined value passed back to the callback + * @param onCommandResultListener Callback to be called on completion + */ + public void addCommand(String command, int code, + OnCommandResultListener onCommandResultListener) { + addCommand(new String[] { + command + }, code, onCommandResultListener); + } + + /** + *

+ * Add a command to execute, with a callback. This callback gobbles the + * output line by line without buffering it and also returns the result + * code on completion. + *

+ *

+ * The thread on which the callback executes is dependent on various + * factors, see {@link Interactive} for further details + *

+ * + * @param command Command to execute + * @param code User-defined value passed back to the callback + * @param onCommandLineListener Callback + */ + public void addCommand(String command, int code, OnCommandLineListener onCommandLineListener) { + addCommand(new String[] { + command + }, code, onCommandLineListener); + } + + /** + * Add commands to execute + * + * @param commands Commands to execute + */ + public void addCommand(List commands) { + addCommand(commands, 0, (OnCommandResultListener) null); + } + + /** + *

+ * Add commands to execute, with a callback to be called on completion + * (of all commands) + *

+ *

+ * The thread on which the callback executes is dependent on various + * factors, see {@link Interactive} for further details + *

+ * + * @param commands Commands to execute + * @param code User-defined value passed back to the callback + * @param onCommandResultListener Callback to be called on completion + * (of all commands) + */ + public void addCommand(List commands, int code, + OnCommandResultListener onCommandResultListener) { + addCommand(commands.toArray(new String[commands.size()]), code, onCommandResultListener); + } + + /** + *

+ * Add commands to execute, with a callback. This callback gobbles the + * output line by line without buffering it and also returns the result + * code on completion. + *

+ *

+ * The thread on which the callback executes is dependent on various + * factors, see {@link Interactive} for further details + *

+ * + * @param commands Commands to execute + * @param code User-defined value passed back to the callback + * @param onCommandLineListener Callback + */ + public void addCommand(List commands, int code, + OnCommandLineListener onCommandLineListener) { + addCommand(commands.toArray(new String[commands.size()]), code, onCommandLineListener); + } + + /** + * Add commands to execute + * + * @param commands Commands to execute + */ + public void addCommand(String[] commands) { + addCommand(commands, 0, (OnCommandResultListener) null); + } + + /** + *

+ * Add commands to execute, with a callback to be called on completion + * (of all commands) + *

+ *

+ * The thread on which the callback executes is dependent on various + * factors, see {@link Interactive} for further details + *

+ * + * @param commands Commands to execute + * @param code User-defined value passed back to the callback + * @param onCommandResultListener Callback to be called on completion + * (of all commands) + */ + public synchronized void addCommand(String[] commands, int code, + OnCommandResultListener onCommandResultListener) { + this.commands.add(new Command(commands, code, onCommandResultListener, null)); + runNextCommand(); + } + + /** + *

+ * Add commands to execute, with a callback. This callback gobbles the + * output line by line without buffering it and also returns the result + * code on completion. + *

+ *

+ * The thread on which the callback executes is dependent on various + * factors, see {@link Interactive} for further details + *

+ * + * @param commands Commands to execute + * @param code User-defined value passed back to the callback + * @param onCommandLineListener Callback + */ + public synchronized void addCommand(String[] commands, int code, + OnCommandLineListener onCommandLineListener) { + this.commands.add(new Command(commands, code, null, onCommandLineListener)); + runNextCommand(); + } + + /** + * Run the next command if any and if ready, signals idle state if no + * commands left + */ + private void runNextCommand() { + runNextCommand(true); + } + + /** + * Called from a ScheduledThreadPoolExecutor timer thread every second + * when there is an outstanding command + */ + private synchronized void handleWatchdog() { + final int exitCode; + + if (watchdog == null) + return; + if (watchdogTimeout == 0) + return; + + if (!isRunning()) { + exitCode = OnCommandResultListener.SHELL_DIED; + Debug.log(String.format("[%s%%] SHELL_DIED", shell.toUpperCase(Locale.ENGLISH))); + } else if (watchdogCount++ < watchdogTimeout) { + return; + } else { + exitCode = OnCommandResultListener.WATCHDOG_EXIT; + Debug.log(String.format("[%s%%] WATCHDOG_EXIT", shell.toUpperCase(Locale.ENGLISH))); + } + + if (handler != null) { + postCallback(command, exitCode, buffer); + } + + // prevent multiple callbacks for the same command + command = null; + buffer = null; + idle = true; + + watchdog.shutdown(); + watchdog = null; + kill(); + } + + /** + * Start the periodic timer when a command is submitted + */ + private void startWatchdog() { + if (watchdogTimeout == 0) { + return; + } + watchdogCount = 0; + watchdog = new ScheduledThreadPoolExecutor(1); + watchdog.scheduleAtFixedRate(new Runnable() { + @Override + public void run() { + handleWatchdog(); + } + }, 1, 1, TimeUnit.SECONDS); + } + + /** + * Disable the watchdog timer upon command completion + */ + private void stopWatchdog() { + if (watchdog != null) { + watchdog.shutdownNow(); + watchdog = null; + } + } + + /** + * Run the next command if any and if ready + * + * @param notifyIdle signals idle state if no commands left ? + */ + private void runNextCommand(boolean notifyIdle) { + // must always be called from a synchronized method + + boolean running = isRunning(); + if (!running) + idle = true; + + if (running && idle && (commands.size() > 0)) { + Command command = commands.get(0); + commands.remove(0); + + buffer = null; + lastExitCode = 0; + lastMarkerSTDOUT = null; + lastMarkerSTDERR = null; + + if (command.commands.length > 0) { + try { + if (command.onCommandResultListener != null) { + // no reason to store the output if we don't have an + // OnCommandResultListener + // user should catch the output with an + // OnLineListener in this case + buffer = Collections.synchronizedList(new ArrayList()); + } + + idle = false; + this.command = command; + startWatchdog(); + for (String write : command.commands) { + Debug.logCommand(String.format("[%s+] %s", + shell.toUpperCase(Locale.ENGLISH), write)); + STDIN.write((write + "\n").getBytes("UTF-8")); + } + STDIN.write(("echo " + command.marker + " $?\n").getBytes("UTF-8")); + STDIN.write(("echo " + command.marker + " >&2\n").getBytes("UTF-8")); + STDIN.flush(); + } catch (IOException e) { + // STDIN might have closed + } + } else { + runNextCommand(false); + } + } else if (!running) { + // our shell died for unknown reasons - abort all submissions + while (commands.size() > 0) { + postCallback(commands.remove(0), OnCommandResultListener.SHELL_DIED, null); + } + } + + if (idle && notifyIdle) { + synchronized (idleSync) { + idleSync.notifyAll(); + } + } + } + + /** + * Processes a STDOUT/STDERR line containing an end/exitCode marker + */ + private synchronized void processMarker() { + if (command.marker.equals(lastMarkerSTDOUT) + && (command.marker.equals(lastMarkerSTDERR))) { + postCallback(command, lastExitCode, buffer); + stopWatchdog(); + command = null; + buffer = null; + idle = true; + runNextCommand(); + } + } + + /** + * Process a normal STDOUT/STDERR line + * + * @param line Line to process + * @param listener Callback to call or null + */ + private synchronized void processLine(String line, OnLineListener listener) { + if (listener != null) { + if (handler != null) { + final String fLine = line; + final OnLineListener fListener = listener; + + startCallback(); + handler.post(new Runnable() { + @Override + public void run() { + try { + fListener.onLine(fLine); + } finally { + endCallback(); + } + } + }); + } else { + listener.onLine(line); + } + } + } + + /** + * Add line to internal buffer + * + * @param line Line to add + */ + private synchronized void addBuffer(String line) { + if (buffer != null) { + buffer.add(line); + } + } + + /** + * Increase callback counter + */ + private void startCallback() { + synchronized (callbackSync) { + callbacks++; + } + } + + /** + * Schedule a callback to run on the appropriate thread + */ + private void postCallback(final Command fCommand, final int fExitCode, + final List fOutput) { + if (fCommand.onCommandResultListener == null && fCommand.onCommandLineListener == null) { + return; + } + if (handler == null) { + if ((fCommand.onCommandResultListener != null) && (fOutput != null)) + fCommand.onCommandResultListener.onCommandResult(fCommand.code, fExitCode, + fOutput); + if (fCommand.onCommandLineListener != null) + fCommand.onCommandLineListener.onCommandResult(fCommand.code, fExitCode); + return; + } + startCallback(); + handler.post(new Runnable() { + @Override + public void run() { + try { + if ((fCommand.onCommandResultListener != null) && (fOutput != null)) + fCommand.onCommandResultListener.onCommandResult(fCommand.code, + fExitCode, fOutput); + if (fCommand.onCommandLineListener != null) + fCommand.onCommandLineListener + .onCommandResult(fCommand.code, fExitCode); + } finally { + endCallback(); + } + } + }); + } + + /** + * Decrease callback counter, signals callback complete state when + * dropped to 0 + */ + private void endCallback() { + synchronized (callbackSync) { + callbacks--; + if (callbacks == 0) { + callbackSync.notifyAll(); + } + } + } + + /** + * Internal call that launches the shell, starts gobbling, and starts + * executing commands. See {@link Interactive} + * + * @return Opened successfully ? + */ + private synchronized boolean open() { + Debug.log(String.format("[%s%%] START", shell.toUpperCase(Locale.ENGLISH))); + + try { + // setup our process, retrieve STDIN stream, and STDOUT/STDERR + // gobblers + if (environment.size() == 0) { + process = Runtime.getRuntime().exec(shell); + } else { + Map newEnvironment = new HashMap(); + newEnvironment.putAll(System.getenv()); + newEnvironment.putAll(environment); + int i = 0; + String[] env = new String[newEnvironment.size()]; + for (Map.Entry entry : newEnvironment.entrySet()) { + env[i] = entry.getKey() + "=" + entry.getValue(); + i++; + } + process = Runtime.getRuntime().exec(shell, env); + } + + STDIN = new DataOutputStream(process.getOutputStream()); + STDOUT = new StreamGobbler(shell.toUpperCase(Locale.ENGLISH) + "-", + process.getInputStream(), new OnLineListener() { + @Override + public void onLine(String line) { + synchronized (Interactive.this) { + if (command == null) { + return; + } + if (line.startsWith(command.marker)) { + try { + lastExitCode = Integer.valueOf( + line.substring(command.marker.length() + 1), 10); + } catch (Exception e) { + // this really shouldn't happen + e.printStackTrace(); + } + lastMarkerSTDOUT = command.marker; + processMarker(); + } else { + addBuffer(line); + processLine(line, onSTDOUTLineListener); + processLine(line, command.onCommandLineListener); + } + } + } + }); + STDERR = new StreamGobbler(shell.toUpperCase(Locale.ENGLISH) + "*", + process.getErrorStream(), new OnLineListener() { + @Override + public void onLine(String line) { + synchronized (Interactive.this) { + if (command == null) { + return; + } + if (line.startsWith(command.marker)) { + lastMarkerSTDERR = command.marker; + processMarker(); + } else { + if (wantSTDERR) + addBuffer(line); + processLine(line, onSTDERRLineListener); + } + } + } + }); + + // start gobbling and write our commands to the shell + STDOUT.start(); + STDERR.start(); + + running = true; + closed = false; + + runNextCommand(); + + return true; + } catch (IOException e) { + // shell probably not found + return false; + } + } + + /** + * Close shell and clean up all resources. Call this when you are done + * with the shell. If the shell is not idle (all commands completed) you + * should not call this method from the main UI thread because it may + * block for a long time. This method will intentionally crash your app + * (if in debug mode) if you try to do this anyway. + */ + public void close() { + boolean _idle = isIdle(); // idle must be checked synchronized + + synchronized (this) { + if (!running) + return; + running = false; + closed = true; + } + + // This method should not be called from the main thread unless the + // shell is idle and can be cleaned up with (minimal) waiting. Only + // throw in debug mode. + if (!_idle && Debug.getSanityChecksEnabledEffective() && Debug.onMainThread()) { + Debug.log(ShellOnMainThreadException.EXCEPTION_NOT_IDLE); + throw new ShellOnMainThreadException(ShellOnMainThreadException.EXCEPTION_NOT_IDLE); + } + + if (!_idle) + waitForIdle(); + + try { + try { + STDIN.write(("exit\n").getBytes("UTF-8")); + STDIN.flush(); + } catch (IOException e) { + if (e.getMessage().contains("EPIPE")) { + // we're not running a shell, the shell closed STDIN, + // the script already contained the exit command, etc. + } else { + throw e; + } + } + + // wait for our process to finish, while we gobble away in the + // background + process.waitFor(); + + // make sure our threads are done gobbling, our streams are + // closed, and the process is destroyed - while the latter two + // shouldn't be needed in theory, and may even produce warnings, + // in "normal" Java they are required for guaranteed cleanup of + // resources, so lets be safe and do this on Android as well + try { + STDIN.close(); + } catch (IOException e) { + // STDIN going missing is no reason to abort + } + STDOUT.join(); + STDERR.join(); + stopWatchdog(); + process.destroy(); + } catch (IOException e) { + // various unforseen IO errors may still occur + } catch (InterruptedException e) { + // this should really be re-thrown + } + + Debug.log(String.format("[%s%%] END", shell.toUpperCase(Locale.ENGLISH))); + } + + /** + * Try to clean up as much as possible from a shell that's gotten itself + * wedged. Hopefully the StreamGobblers will croak on their own when the + * other side of the pipe is closed. + */ + public synchronized void kill() { + running = false; + closed = true; + + try { + STDIN.close(); + } catch (IOException e) { + // in case it was closed + } + try { + process.destroy(); + } catch (Exception e) { + // in case it was already destroyed or can't be + } + } + + /** + * Is our shell still running ? + * + * @return Shell running ? + */ + public boolean isRunning() { + if (process == null) { + return false; + } + try { + process.exitValue(); + return false; + } catch (IllegalThreadStateException e) { + // if this is thrown, we're still running + } + return true; + } + + /** + * Have all commands completed executing ? + * + * @return Shell idle ? + */ + public synchronized boolean isIdle() { + if (!isRunning()) { + idle = true; + synchronized (idleSync) { + idleSync.notifyAll(); + } + } + return idle; + } + + /** + *

+ * Wait for idle state. As this is a blocking call, you should not call + * it from the main UI thread. If you do so and debug mode is enabled, + * this method will intentionally crash your app. + *

+ *

+ * If not interrupted, this method will not return until all commands + * have finished executing. Note that this does not necessarily mean + * that all the callbacks have fired yet. + *

+ *

+ * If no Handler is used, all callbacks will have been executed when + * this method returns. If a Handler is used, and this method is called + * from a different thread than associated with the Handler's Looper, + * all callbacks will have been executed when this method returns as + * well. If however a Handler is used but this method is called from the + * same thread as associated with the Handler's Looper, there is no way + * to know. + *

+ *

+ * In practice this means that in most simple cases all callbacks will + * have completed when this method returns, but if you actually depend + * on this behavior, you should make certain this is indeed the case. + *

+ *

+ * See {@link Interactive} for further details on threading and + * handlers + *

+ * + * @return True if wait complete, false if wait interrupted + */ + public boolean waitForIdle() { + if (Debug.getSanityChecksEnabledEffective() && Debug.onMainThread()) { + Debug.log(ShellOnMainThreadException.EXCEPTION_WAIT_IDLE); + throw new ShellOnMainThreadException(ShellOnMainThreadException.EXCEPTION_WAIT_IDLE); + } + + if (isRunning()) { + synchronized (idleSync) { + while (!idle) { + try { + idleSync.wait(); + } catch (InterruptedException e) { + return false; + } + } + } + + if ((handler != null) && + (handler.getLooper() != null) && + (handler.getLooper() != Looper.myLooper())) { + // If the callbacks are posted to a different thread than + // this one, we can wait until all callbacks have called + // before returning. If we don't use a Handler at all, the + // callbacks are already called before we get here. If we do + // use a Handler but we use the same Looper, waiting here + // would actually block the callbacks from being called + + synchronized (callbackSync) { + while (callbacks > 0) { + try { + callbackSync.wait(); + } catch (InterruptedException e) { + return false; + } + } + } + } + } + + return true; + } + + /** + * Are we using a Handler to post callbacks ? + * + * @return Handler used ? + */ + public boolean hasHandler() { + return (handler != null); + } + } +} diff --git a/app/src/main/java/eu/chainfire/libsuperuser/ShellNotClosedException.java b/app/src/main/java/eu/chainfire/libsuperuser/ShellNotClosedException.java new file mode 100644 index 0000000..2a44083 --- /dev/null +++ b/app/src/main/java/eu/chainfire/libsuperuser/ShellNotClosedException.java @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2012-2014 Jorrit "Chainfire" Jongma + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package eu.chainfire.libsuperuser; + +/** + * Exception class used to notify developer that a shell was not close()d + */ +@SuppressWarnings("serial") +public class ShellNotClosedException extends RuntimeException { + public static final String EXCEPTION_NOT_CLOSED = "Application did not close() interactive shell"; + + public ShellNotClosedException() { + super(EXCEPTION_NOT_CLOSED); + } +} diff --git a/app/src/main/java/eu/chainfire/libsuperuser/ShellOnMainThreadException.java b/app/src/main/java/eu/chainfire/libsuperuser/ShellOnMainThreadException.java new file mode 100644 index 0000000..69732e3 --- /dev/null +++ b/app/src/main/java/eu/chainfire/libsuperuser/ShellOnMainThreadException.java @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2012-2014 Jorrit "Chainfire" Jongma + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package eu.chainfire.libsuperuser; + +/** + * Exception class used to crash application when shell commands are executed + * from the main thread, and we are in debug mode. + */ +@SuppressWarnings("serial") +public class ShellOnMainThreadException extends RuntimeException { + public static final String EXCEPTION_COMMAND = "Application attempted to run a shell command from the main thread"; + public static final String EXCEPTION_NOT_IDLE = "Application attempted to wait for a non-idle shell to close on the main thread"; + public static final String EXCEPTION_WAIT_IDLE = "Application attempted to wait for a shell to become idle on the main thread"; + + public ShellOnMainThreadException(String message) { + super(message); + } +} diff --git a/app/src/main/java/eu/chainfire/libsuperuser/StreamGobbler.java b/app/src/main/java/eu/chainfire/libsuperuser/StreamGobbler.java new file mode 100644 index 0000000..4ce6697 --- /dev/null +++ b/app/src/main/java/eu/chainfire/libsuperuser/StreamGobbler.java @@ -0,0 +1,105 @@ +/* + * Copyright (C) 2012-2014 Jorrit "Chainfire" Jongma + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package eu.chainfire.libsuperuser; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.util.List; + +/** + * Thread utility class continuously reading from an InputStream + */ +public class StreamGobbler extends Thread { + /** + * Line callback interface + */ + public interface OnLineListener { + /** + *

Line callback

+ * + *

This callback should process the line as quickly as possible. + * Delays in this callback may pause the native process or even + * result in a deadlock

+ * + * @param line String that was gobbled + */ + void onLine(String line); + } + + private String shell = null; + private BufferedReader reader = null; + private List writer = null; + private OnLineListener listener = null; + + /** + *

StreamGobbler constructor

+ * + *

We use this class because shell STDOUT and STDERR should be read as quickly as + * possible to prevent a deadlock from occurring, or Process.waitFor() never + * returning (as the buffer is full, pausing the native process)

+ * + * @param shell Name of the shell + * @param inputStream InputStream to read from + * @param outputList List to write to, or null + */ + public StreamGobbler(String shell, InputStream inputStream, List outputList) { + this.shell = shell; + reader = new BufferedReader(new InputStreamReader(inputStream)); + writer = outputList; + } + + /** + *

StreamGobbler constructor

+ * + *

We use this class because shell STDOUT and STDERR should be read as quickly as + * possible to prevent a deadlock from occurring, or Process.waitFor() never + * returning (as the buffer is full, pausing the native process)

+ * + * @param shell Name of the shell + * @param inputStream InputStream to read from + * @param onLineListener OnLineListener callback + */ + public StreamGobbler(String shell, InputStream inputStream, OnLineListener onLineListener) { + this.shell = shell; + reader = new BufferedReader(new InputStreamReader(inputStream)); + listener = onLineListener; + } + + @Override + public void run() { + // keep reading the InputStream until it ends (or an error occurs) + try { + String line; + while ((line = reader.readLine()) != null) { + Debug.logOutput(String.format("[%s] %s", shell, line)); + if (writer != null) writer.add(line); + if (listener != null) listener.onLine(line); + } + } catch (IOException e) { + // reader probably closed, expected exit condition + } + + // make sure our stream is closed and resources will be freed + try { + reader.close(); + } catch (IOException e) { + // read already closed + } + } +} diff --git a/app/src/main/res/drawable-hdpi/activitydetection.png b/app/src/main/res/drawable-hdpi/activitydetection.png new file mode 100644 index 0000000000000000000000000000000000000000..e1ca6ab3a92ad8592458e263ed7a2557209d169e GIT binary patch literal 2835 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-hdpi/alarm.png b/app/src/main/res/drawable-hdpi/alarm.png new file mode 100644 index 0000000000000000000000000000000000000000..ef7a244473b6477a239dda9bf95c0ff50c861eb3 GIT binary patch literal 2406 zcmV-s37PhZP)N2bPDNB8 zb~7$DE-^7j^FlWO00`nqL_t(&L)DrIY|eKW#}(U1mgtsjqqNhZuB1rarFB&a<_cAU zpz4Stb#|+aH8Mu5)nH0YTSuL7)Rm%jl%lPcqRw6vVcBM6Sar|7-(TL}n}1&a_myRp z{NE-Hv;c~N^xsVE%!1}Z(NL1@{$gyudKZ}L z@AC}vF%VLBo6w0z<>dvvu4d&GI{dk)M?YE&kuTR@=O)Z?Td+tiG%$& z_?=#E1qO|;GkWysg05Y=I>N9Ycj?ka`uFc&GGoS!rvOtrefsp|xpU_#M}vcdf8li# zFzOtyjTkYa5c?my4Hz`m6UuVtRJ(TVBp@I_x_9p`At51q=osLH&6zW&u67dV6OlI3 zzI}V){myLRd_kv9oxZ5K9((Nxy6 zXHQ=`g^1}G5fRZ+gTeXwfq{WVZQHgLUteGKT=VA5g?3CJW#in3maZ{qV7M6+6i#W@ zteMoWUtgLwZ7Og$6HYeJAP_O1L`Ft_Z7jyH^C_Yw&CkzI8Z>C2z>FF-N;-7tUuYhu(*SH_GPBj}N2=FFKgb?Q_>w=TVV_ZEPmDxv*=l8)yq{r&xwJ=$&3 zq=~9QHaK^!4kn3pfFN48ZY_A*jFMvPM-3i4I2S+^jQR8D3%Xj#$jFe>r%x;G+qciY z&-3Vx1-+E?>eWj@8aQy^c|=YG>=n^2?XyQ0)a!65Y8A`)Jqu>OOn$w!TtgyY~I zJ$h82pb8>JjvYH@2cV&xI(16+?AasS>T`N~q{@MS#(1LU@;q_ix_3Sug@7oIjx+uwMhVz3_Xg zXR|yQLzf#sD8q*jmxBin+M&D)hS_yvx*??q=NaU0?8V#y4AQ0^bPq#**}s3kBqb%u zi4!N@86mEq9Y20tl9Q8V@7}!}7!uAc$bCk>80Oail(j6Hn>KAykz(fXu3fv7le~WB z%o!zP&2a{a_pD#PUKM13`N?gj1c2fPRbrXIrK77>t&))=N6NZ&>*W0T^OBvNt+waR zos+DrECtF{TCr;fnAebd)EGed8OsbRh0LOb=jiy-rAuYluwjBZk~+@K%~iT|>5^Qy za6v&jd-kkT8;mwvPZe+Z;*0dD3oyTNz-E>f8VViXv111ZeX?xXGP!c)ie35n`I48H zrvNdE2+c8awC#x#Co*cD0FbrkN&wS`wS^9wMGKuI6h;OC5D4Z;3c`&WH*z#l;Z}>rHn{_ey~B9l_8EM=-1zObHO{6x0M(*1X5aBD);W)Q|AbUqv7StmkSoL)Le?Qbl#huo^JmQ z)-yy*lGVXvVCC*DFa*WkhHszI!gL{s;^JZ{FE3Z)oY>e{HP+d%VS}0i5X8!rD`n@- zovMc-*o1@x;dsV4br?EyD8U@HI+(0+HCH5A^us5qQH*ellg|@7$Ou?ZD zh3Ul}s;H<)^;|5%EZUCa8QRo?Jb;O^I+#F$iI0zetGnh{gku=?N;;hw6@P|Uu|kc0u_n{r>R>)VXg|b?ztePLA!QV>%ck>;9Nldb2#O`jL6h*|Xyyk5R+7&ssw`be`!#5EN?)j~OX?TEO1S zELzy>aj6tgVl6*cvVmy`Fn{sOfZ0G#!(rsmc>*E`iiMWPOdm#yo=6(!O4{ax2@?qA zIrO<(fU&_@!l>bZjEA{*q0EEOS;+DsZDqc56inc*}T(V%aK;O8{ zdW;QB9e~N}*RP+Xrl#7z2splZ0%C7N2wFTgTW%m2&Z{U+0|4a$qUA%k0%L>Y3pkIs z5Y8nASF3aSnzPkDeVwCS!UmKFkdND~`RWE^6)%hfJ}h_2nl)?w*H;4ktC?Esr7g^( zh8Ur^O^sngu}n}0i`NBks1T7;!0` z_B3)UF!+wN0uH={1O5P07g`3rVtrtb#R$^tHUwhaKXmAjD%>0o5h#GXgkqsOuonQk zud!X~cBzC$_q6@T(;Q>t0p?360nYwPhbh(|e!u1d6qhWxp2M$}Ha*2Q4)QkIf&FOM zuf#Uct%@%iJPg{1#@BMJ1-jP)lo059Xg8DvW$-%%$|qs+R$cb(E9@O YFKW&>(DP&KIRF3v07*qoM6N<$fPx#1ZP1_K>z@;j|==^1poj5AY({UO#lFTCIA3{ga82g0001h=l}q9FaQARU;qF* zm;eA5aGbhPJOBUy8gxZibW?9;ba!ELWdKlNX>N2bPDNB8b~7$DE-^7j^FlWO016^W zL_t(&L*3e0P+Qj>2JrZyFX?oq%~LwlB#w>EYWB@+0wjUNBC)Rm2}vL%cEr92B#^`^ z#16)UEx|R|K-pauJ8Xv7#suO3j&a?z=}gk6&csPb();y5rkQq{bn@anT+MtV25EG! ze*DjwdztSHfR|qMKmGLOFGgzeLYG_N|2eE`N@y{v0n7K z{`>P^ILgU^s;a7-ySuv|PEJlf-rCwaeD>_w;h)HZ{EYeed0e}84ILdFFc=Kb>-A8p z)!%5f+Q$_Y6$eE{MUQfGa~~0`rL3&1-_Q!Cyu5spd{OlG_hV^k35SP=c>MS=*4NiD zF);yxhLhLJ%F2+RpAQ0n)YMdn#bU(A$0IT_5@BIskjZ4Zw1QD8l}8$l27P^fSX^BE z9%gNA4P#?t=<4bMnJN?)7lXVP>FMc6NlAfFCUsesMo)@;}K2I%6{z{xLI!??< zI4)EdeyddFeJfQae-kVTKIV$J$H7wW*P?7*4Xt1X59->oHpCb>?8U%Gz3BhwD*7Jx zp!|Lj;+LWjI~Re7-f)C=g(IXp5?w1-(YbmR#nY8w_wc~%4MNmdICOV?6KDlzT#lINr0+Gz^MnhS_7G)GFgIixB}49>_fFp~;hKOZq=7vL^` z6K^J8gl5%?UNF}W>lMdc%HHQ_$5@rOZKvxc>t_*yI0I#^6$FDqo2NQ`Is@J>|X|>0U92ktkF+a3E zAk*>znU+UYFm7ugpNa*u-4+b}CG^bLU}MJu>pPZs^wbR>kUThW#Jk&O&^C)wZgS9aPluLW0<%|zrh6JF{tyRNn>~E=wqS|v;U{v2PofJ-+mtA3RYIVO zgH@b0&PH5>X^JKEYiuE{CT4Ws*qk)VMe`Oxc}S*ZM+3u_8jA5a__a8|S7(pQVYYA% zawL0=6EZagNYmsaC@l`JvMlfl>paY5R;XF?7tso)b34x{z8-+)4K0lK$+XW)hitzfD*;+n+6 zfiSL;O?R^jhD|jZRte0A033rW*cvA^yyJ+m1zU{Xvc>W}CYIh~VrtbLL-SV1Znwf~ zNv|P)(OgU`811^iD0w>=hC5^lt$l}5f4c&TVF9@Hm*H3G0!EY*yuv)-#B)PRX(q%a z8Q`Wy<8_V=UgetMb@3Z0ShS)SjBY)#Su(&wM6%<1P1k|{}Pvr_m zq%*ui2~3b1#07E)^X2f9M&J!U8~oPa9A_nGQM6;nz{tJ~ zHM8ZA_YoMa2mH(2&^F?TTPxO>y>khx_ua8VvT)ZC6U!DT>9)c-={XcH*-2>yQ?r`X zD!medI&xEJSSrEJUm~HKEQ7p9fIzh;I7RM=QMyA?>Vx@V_{yB&kZ6aCDW)h}bfp>09chQe5QeUW9DMb6Hje(v zNB6BX=&na2v4#mwrWd+zy5QX{J1pO|#oD$DR!MH(bHM!FOHdEm!Axcb)snl6UK6t{ z?GV?6VeOFs#{}lPu<+$)Ok}kCfuryOGu#vYQ5?AQeGnpzLy$BUUV>nl1-s%L-vQ>S z7N}VCOr;f!eo4}iR1=D^ds58Z7h!cj?i6PKDF=a>KJZWRf^R6Rsh&^jjL8auvO4=TO~W#@jwB-?D;EB-zFt6(->zjocjmXJRB#VDo*+GV+Eu zlYsy}5AJLhT>RK@45+acWvx`kkR!DyyMT_FknkY%PomPK;%OcE)G z0F&zjAAfH!ya^1C4|gUTE-V7$&xRe@Z)|uzxD@6I#|&ra7x#*h$umufQoO8 zr4ru?rRtXi`Lu#DG#UQ(R$m`AH9bXbZf#OWPmf5RQri!=spZ?t)Y$kK)j!Zr4Ga!Y z?H%n@ld*}atFNbYdL5hU*rq?Q4M7A QcK`qY07*qoM6N<$f){NI$p8QV literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-hdpi/bluetooth.png b/app/src/main/res/drawable-hdpi/bluetooth.png new file mode 100644 index 0000000000000000000000000000000000000000..34ca5fc8f5426d1ad255d65bcb644ea93071746e GIT binary patch literal 1536 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-hdpi/contacts.png b/app/src/main/res/drawable-hdpi/contacts.png new file mode 100644 index 0000000000000000000000000000000000000000..1eaa428d14400add34c4caf174807a78a127911d GIT binary patch literal 2824 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%0Abl}4Mn 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%0DfL#dUnoDsb04KQa3pdEgQ@*iSNO)~$xCy~} zEYabyxw$nW7`Mhhmpa_`B(GgpGxT^1+%HXO6?Gn7#*heF_;1?>w&?<6y9?M z2=cD%L?i^4KJV<3X6}_I$!Y>BT3Ses<@TI&SDX0?&+#Ucu#FWNn5aCIsruH4S?Qc9fc^b0fEWzi zjo++#(`@=D%I~ZWb?r&x`r`Q={rhqM;~qIA6!!UZC(J7ZknMe{lx(?w^X6rv`ErCu zftB~bN#gHQ3Hn%K5P~!oA`gMB!jIqW`CoRdIe9d;7pOFV%aFBXAJe7`o?9IoO7L4oowos$=fgBme&0%yr;o* zp{V}p9mjU&)GOD(s0)=K--Ic2ONrz-g<-23VdEVc(*JV7Qt1Zs>Ca|-=Oi3x<1!MC z4qm;&o4btgBE#jd__XN4IyJ_Af%@wcnhOA_bE4|v zspWCY4iyD#aFLgeuNFC$o(#m9PYq~=7i?d z4@I8X1~J=X;Z~olK25d9XJ=+-z9&yqVE&}a6}qvsv9uQ%94b7wf<3*N=*@iq;=YO-vSee)jy#0Ut1-aa%Tk zd$ABC40{93ppJ|6_43y}Bkc>}GX(Av8KYy$*`}Y!=dm|G-y_=OX4q~88^1MJNI|C2 zH1`g7s?6Hoswwe#0wtnT8ud3fBjzuTVVe9=fck@;#N3zw`+m~{P1YqIOkcr6cN8Sg zwoM}AZyGSQpd~o^AgtL^1v6o;^q1W?3hb7S%Bua)#|>KU6ZZCr=80xL8&w}cKOpom zbM#|7DIt^qpu>L>A_wcM^ zd;^{3Vnd2agL`Ri=>)Pv8>ovPlfits+tXGsLq3E8=6%SbTyrk)7Mh{KQUcC{A<% zTwyh25dw0A>uHBWS4?Z7J|(A8#V@~mo0C(?C^jzGZ{;$UE!bRrr2shH zBa>#o&7<+Pdz5RzCfY$9R?++exZ?V6GZU{>q|^4ajbR%;A#`X6C#EoP{6AEAb?9D_ zabS`BOw#;A)+cmoCA#oQM#tr{&{wBjDIif)A{8sWGZT<`=LREk}ymJHt(4av@05)93;Ve-52I?fcU2P@52! zg5$~3$kM!tlp|8Go|5AP^l1ELTI<*WsP4s`gMAg+zev#GemqP?og3ePm&p?X9fE#e z{DquxoF!0Tfv80?TsbP+`ck)>7eg8N@f0}}Ij^xwRJ79|$H?2ffI$C0&htih$^Mza znL&XtI?|1hKhg#}81+$N-_3A*=-Aad-~xjFt=aItBTsWd_kk;mS7O@sJ>B?6%Nqen zz+P1_56WB|cHC=?D8_>5<#K=9u;u$gHU%I!D~_bVywosE|Yg_T92QA&+bkoX0$F5?;a= zV(PM=p65&{RJGwPASuH=&$t1VNr`$7O{^@4IB_mk|9)ljw|diUf{blg`d{}Zr%P&s=nk%1ODvWf!-Y?Pqi5|Dxvdv z&}dXe*9Vok6dt4R{*q?_7~lEB%;=L#op>m06*Axh1xH8Tpa>zkP*@6YL-q z=wK(HIDjadX_UYgz3Cbzs1-JA@FC-pkL+{|2L3S&03+H2Cf-}{)McdmVPtJbX#c7mN#O_mnwsde8>00h}v z>TX3o|Nd>YWv886*m)rtg`bY?nS@4_}k+w z$>Jws;2-C!zvGx|g83i$Quo+?>dNNje@Sc zpAEeDgvt~|?TXwJA1sb*-#lRIOt|{P&|NzoEiN_Y&y-!-iKmC#6ud&SfgSON=GYZ2 zlpuF$uKG9Z|cN3bWa@+8eWiBc*Ipp$e#ve4% z6HU>ilOQ%%{Zn9WfN^J~DQeND$-Z4eMC@i%H{30nuzbUD&K(q+x_O7^eUheN+)-;R zF;7lX!|JDoSBo3Ujc)muE-KqNewGl5a+ET2P3_m(ugkFZ?kkQ~_x@pB=2l+2x0BNS zlKdsf%Zk+UGjihZ(*b_(mdN3ij*aX6;NNa7;(^Ntzs)|?^v%U>T+iz6ymF)5z!{__ zT0-6Bo-{2Kjj-uPmD!t~DjOK~?EbfuCtsycpH4YUZbRpCp zw^E#JPoQ`*Umfwk$oMA+*{~rEHD7M_<$Fcs7TEUEM2*sc@b;)Vw<~>*vKHcl6;J0@ zL7_%r;0Mh|Fa)d0gEIVQ%jH~XN6R;v26^w*Ww~zy937_4_e&{pP24By$I0=rhAFVaS{r7n6R3i{SES}l1`}? zi!lwN9ie9>n>s_E!b?|61IqTWN(8l?AM-1Q)Xo)gnds_lL{Rd8Z6@oYmT=HGQ>q zUwlmqIj=si=8t}F_a`m?c=~#8QMT@{l6l@F{l#rq8|p5u+_odpXF`PY9(Tgy(Y1Nt z)w@wo0L4EX1cbrg`a#?8CGN!%H=+~eo_y>v<66N*PABFzGneuDOqdfD{M4KwLi-}> zEfZ46Ni*I+8RW9W+AiZY$*h95m%J*-3w4?h+|BCR{eAJyH>hqL)Po{z%fXzq_!_rY zuH|k3M1ICf${vuY-PE1b9TLAzW_cKy&jEnM6LtdPXbi=26#&sIt94{qe=U3(HouIE zYK6Fdu3WDNp2gSUP2P0lV=IOUbE}Sk%m3ROyBTo#KhR_7ilEzeJ?R)MYg0~U-ZDA@ z)R9io-A0P_dcCP*v=g4YwSgG}?-soeJ6;jXjPm8YJL_d$-TajCTv=_8LA;Y*hYt?o_ehahi?=_*JJhYoHLeG zq@Tv7zBk5M!841QNRvsjPPjnRWX3LBF+Hxj=FV@5I2~Z{Ne+Dx#P>{NMCY9D)M0(T zw+@dA25ve}Kkzk_&B4!qaevVy(gQksX*x@r88C5?RG25#j(;gXMG5brW~?(CB%uY; zzmT3OflwbQu(+iy84Q+4GINoU!{4k}qX%i%-P`NqhrS?VwD`P>`&Vst>VV-OSiJ*RKG@8$v-m6a zX57QWn0O;YteoNDeY-}7=4<7SlXFb~#fr4il-ueQ13~7xmg7gY zk+0^w*I9QXP&_Og6x2{lXU>As#lAyObHoEx3!Ie9J@_!i%MN*>Zb-(<(2SX(uN4DH z4~(36!+ROK68YJCf5!+vI!M*VT1IRRryNe~4{uw6M)+W1XC95U-dJsav&n6+zz_YLPYYGClvX7i96X3w|9-?3`WHU1`An{A1@Z-aFWDnSl&$qdonN z)LHP9YQMvf!_Y>T;~&uB5tbN5QxH~c`v$|5Mn(HAcqe;$9a{Wg7*V16QPx>tJ}u-r z6p+4zB_O^V^8jMMl3Ujg*`-aRG^Q;M9qNsH_s{7N^PJD z`ZZ4s;IwX9c(@>=Bp;$R*_ranvZmDb3jfE_T`)x1ZBYQGL0Y;?kPbn*Lr|ooySqcW zI~63PySuw31f(UT8>GAIp7Fc$`~U-IeCM3K*MfuE+AQ?9 z@bWhwF}nRgs0*BU*JvGw4U7zUYYAYZ8%k45&`i)c7$+IF@q?u2IR!<0uUS`b@(a>C zbniECJpl&Y2n0^u0pTuvTKNMMMpjw2u_!F)zH)_#Nar4MhNz0C{|UH;gaBz zz;8pJ`?*tm&uVFG0{rg%0nvv?(|QdX)xf0{5M@JaY8o0lPKRRxmWQMl6T|7s^?mh;SD9I7Tnj_unhK#}|l&!M}f4 zKpz>pR<{zQ(L!|b{{X1uP%ilI(;r7ynXm9XBPku^*3)`<6&#fZKha3}3lC;)%16jv zzhW(`T81nvo*%8MXHP58WPcSkJjH zT(zm65FUeL?+6td_rbGD@DCa46_e+8LB;}sebC{3_wjv$3=kxI_cU=G-BFb{7Ay4e zu4^cpF|>jNS!>o#r_))`xF*^9HOe-X)3;`%3v)ruXqFiLph@nzzf?{i+*eHkUO}ar zSM5NqAe zo@p#=Q?8&O$f%@*e<}S4JTl6S^Zq6IjBuXiJ}!WCW$Ibm&fD?S09k3mgf?A&N%h6) zc45mdu@jBatRk)1@%4=!gh=GRruOVQUy-X_yXQWrLPxL*Y^1zmcq!cs_3azCsI0+L zWwr4cRd9LU&~Uxep|%1fO9|~^{}G^c{Ol{uVaos9}JIG$Hu}hZS!Iyek%)YDDW&xz?P{t+JyX<5ME)( zJoy2})jejFw7+LNfZa5tQh^8pRs%ec7vYa!t|McH1W~7G_OLj4y}V(?&rb`xSim2V ziVe5mhc!%Ve?>K;cyu9NFShxcZ}<$YZ0|OW)Ya#%4?M2~4JEhCy!y>H^Hmf5|5d+4 z@Eb1#(^?cZHacs);QF=!ds|DLul-U?2~vR)J2*fW~6XX8#T#USR-GZiegt z;%w{$gi%5I`fO|jNZlv;Zfqp~mfWKAT@24`A#J9v0&6(6*YEkCqEN!lCe5mj{RCDBG!J^hT74D+K1%Z~XC$2J^T-%@~dOOvHNrUT)Vnl!ys z+{^%4)SG^SaSgChy^15ZW^DL-Ch$VE1(xS0pd;>=$7?(`m=Sj<*P-y4;?!Y%qgP77 z*X?ob5>aGn##w823H#q>3E$??ucbsSd9r~45qoF*`eLfFUQK-6O08}%AF$DQ;`t(9_&Wo5e(Zd~bOruNzkIeR-7;A^tS72!hvP$db>S+c3BC4yvJR$Yu@l}1FNP%xebA4U`kP{o zZjP=Qra^vADF4Bk&bRSl>998IE^bf0#8a$9u0+m~^?gUY7yT_d&wiS7ih!Rv%ZubJ z;_l8r0BM@09CIO!`fLjx5;`h6YD%m;`2pHCl#^dE%INjz^_}3V?6NW9UtEu1C!8D7 z2lQ|Ug*&g^^L%pgUDo{0c=XVSYlh{8HzbbjPVG*);{A(A_Q!x!Fq!FP&%P#fGcQ0c z78#tex!=Fgm0=BvM#OC;061f?#>(78y!7R$ALhfA*%7b`8eHAWDH=c8CN8qX>}LSz z1?8Zj1nW2z#C%yav}MK;kxDB~Bh-u9P#CtAfX%2q1S%^cPQ4Meb0aI{7j`fGl#}%D z%)RS`_~K7GVMk9PvYhw|owDp^8}}Ff8@ul#Q(kx9y1el45Zst$q(lJo%s!ZfsIO;e z0rB6|XVW-0XqXRXt3( zE6<0!Rv7K4Ms?aNBcPdQ zkN;X!-M(pQ(bksRzS0GFof7p9-eEB9 z&?Mf3GezB@!0B?;M$IMUMdBqO+r{~CZ+=>#(P!z-c|UMr(q^|IN|w}QlJrBT#JW=L z6X*B$pYzw^ch)rS%e=Xa9oz7KLho!tUO%>Lxii~ut<~K(hhC|Xy&(2kI9Ui;q2Qqc zV6cQ~e54<6+jY9`M*uWw&G5O_4?!A&KjlGNnzSM*Lb*a;@?SVWkq`66J z3m51-ANj`&kC&5`g?jSoP@_m@K~H2Q^J?{#Ezk^33C$(ZlTQ_XDWI0Cj8?pHbSI(IoZQ zm&$OsqVRC6@W9JLs|Z{_D43efH0%!zX*-Ht1MYgL#?z=SmNQ`D^ElTqT*2XedC(gp#ind@YuG@4-}-3VAGS9Bdp|y=!f3y~p`;*U*s;_b+edX%*u-^!_@uczY#K zaGuO28o|4|LtPK;j{h;eLRJX(Sj9g2bM$9?k-_2EWSY>x^T_i^PwS$jCd{jweKKF0 zE53MgJs+>z1%ssbR&<@!5B+DPF|uaA=dk{DV2=H`H^z2ot8aaSrnnq~WADm5Xhk41# zPN6Vcyg%jK8-xhm^n+%%0t*ikZ5aBVip*UdZOl^*)UD>1ibPMnx*SNdAoFg|JSx2J z1IN6Oypm5bXrCch#(Yi8i+Hvu_MT0Gi)5?m#{k9?oNs_I^y0fCD%Y1czaF=q&Q2al z(4X{utAq)#>}Z$e+R&cf`lbk@JvcoAC;~Mpce0NKtB)i1sn?AJbTd19PM6K_sArg~ zN{z(}Q#M(5#XcqE?pA?Ey&02YB=qQmxBs<0KVED0nNFOo4s_G&a;;J8Vj5OXmR>M~ z6D14{Cd4t)_LM}cdAIEusdIVE{WZxo=qtcYRkaQ{q_q=vzaNZoXFONkWd$0Z_VH98E6f>&tP`rp6hWhC*WJt|EWa@1^PPT<{f&r+;iVbQ|0Wfdv}*`c5;z&HR1xNuYFbTP12u^) zZHnsso7nI@VlGZGXwos^U_5fG}zR5tEb&kQXE;_=A8q(s9;3{L4rQCjB#i>n)!8nS}D>BCKHzTyZ!>; zxnX!>ct-oVwg484z! zcp3N#RY##`+MZJYVemjz}(&rDoHM%^W~I;X{So=RNT;i`*0zew%$h$^=h+9m#! zo`NrQytnR^``pgz(i$Mz%Toh+gz3;H_fiM(!Yp*-a?SvJ;a8=f#jtbD5UVbq`CCXS z@0G8L50u`hEX|DoXaV?v0Ojl}0CxBmY&-~oBrCu#8FGMCoovU(M1Y6-Dq@KXdl-%b z`hXbJ#7GL9zBNnX7)jO#Ns$eBY>CaoG}6tn&;jj`)uUIY9mqEs;tHSMkRCEGmyahM&e&y5d#d zXKC6-k-O9j?&M6-%nJEgSFyQEli5T;G|#Acqbagq*_Zd_D|YR8S0wE_f4`53?q27w zBzC}EY2BA6BT#=Rd4b7Msuh9TF^L`foEF=nwT18cESHCoz=2n;}%K7w8?Y&Rt zgV62Afg3^0DP>NTcFAR&$C(p%AHoAD{w{Q6nhlO{e{GAHe19B2ZK0=Jn)|pZL@G{v zdgYgK5{5nLxe((0Kl&7683z+KyY$v7Ptt9-(Z=M^wWDPm`yv?A z;+Nyu8TaU1baokL(Lj6q~y^``jxPWZ93y}7(yE8K`GC*h67&_ zR22;Bz$!)E0Om*J;<0H+?9Z2E&DaKu%*L^Woo;Pg7VbpxtNw#8AYO?d@*9c%x{ykItd}}0;TMxaSc*<6x71~&Dq$9-}7i1a} z-^(5p(?}!yH$(edD1Z6Zx4z`$#C~JnbOA(x3;xM>Db{)EVSo;0hHr-d6NON-QN&rr zS>;lr>M+7a&AJu6A*1bbvpibF+rgyyy=gtKaa&EwkUECGwq&9IJ#6s>kH zD+e8`Ae54*ZEM-lj@L~OLgd68pxeCL0mSWHAVjq=mwmD1@A81L*31wEvHNm##5S7*F`1GN;m zchc9=*F)-Je_b3}n{?I{sJ@|kG?b9fonXn<+O?n zM#U1+aD)jMN<@;rDHX%M_f z_zEJ-$gt}S8#BM2A^S@Rz(aejO&)3+6)u2ou@OLqq|h$$Vj7wrYd;v3;# zXt^?wXt1SU$IJN1igTkay+y@i)oe3At&BN{2T0e=x0Ni+SqfrbVL0!;IBDZ zl=tbwD|5x=ytWU#bx&=VJLSTmGqiO=*_SV>Jg=8pkC#a;b(Ho~G#|6}GD@QnMFWu0dRpaF5A4s9}FcjyBC_CrAmYhxhgkMQ`Qk`Id)@h#KX%?ez?PKL8KLq?+Hmow353wLF5VhBXKwW*$U>+y|!2LbH zaK956Ad45I^Td3qu&cWVq$Gaj#qRo-R))Md3(u@s*-wAFWTr{?YIWN7Pejwt= zrk0gX(%~||=6dP7BxIIZJLccs57wY5&o-+bZG5#b$I68i$cr$#Jbwa+i#iZLuAN>Q z4{>ZII}SLH03fUhIKXU5mPXb8Fq9D(h|lGS5v0p93$^g4U=+ouawVXJb;>(i7q{-A zWJ}F+3Fdxkp>VmQ-XOF6YR+l}BYPK7R@i)=^t1SqLi7M^U-Cwmk4b0ED>006r*6Gf z*7t32)43&5D)mDg!LkSe;(_9@2nRVt^`<-W*~hRF{Bv)8MkJ4I>ejbA4gQ2rnSefckeH} zvm6-;9VNEUCS#;@)hBu0Z!n2uKxy{vIzaNy%qk2ezYB!2zyE&!3ChsGdeHAp+3%n^ zgX0E}HYAQPx{wVv%Xtpyk_co_UyJR{PE{7`Q93K`2`)Vg(}ib z_i)~u_Wz!$X=~a1;)<=e{+_V_O6ppw>-qY@(c)Xceu=j!VW2UX?$h3)zh%fiuc z+m=CIsTWilG~r>;5;!!G(rgs(u|zSWrP(|&aX(SN3Zv4;dm$}3NI^%)_cOi3awN25 z&rslebogG_?CF>nv<|J!iu5eEmRgoy3S4_H9q)J{HD7Npr`{t;#N~XLIMo+06)+8| z#w4~9y;ZzbY=+yTc8=v+Ku_=>n!=yLkGEabIM6uoCTN3ghizY=+>Oo?j`a=g<;OaH zKLoR44p?PDcCpiK;JsCt_HSW`aTTB$GE2QG&h8bwWiL57UyCQes-P>U!qGn}-sN*a z>*4F+A1kN!T@r2{53a;@Vw8TGBkrADw{rL+l*#)SpH8ZDfY1?vqbto^?rkQ5cZ-lt zCi=u2#L=qEpfY=c%&cSK&;3&m0fLfjA_fAEFUkEfiQisBz83eYtuvk`EZ95759UPv zrD|!~VcT+rP`F~ePk7Agr~uHV?eZHZiKkjDb?Pe?RvmxvrqxM=1{ZP85LtZ@^;QM& z>hS9U(figb*TdtiKJz!4sBS_hUaPlIb^H*EKig@?;&uj|q7%Nx4nbyA`LP8sJjgBt z++>aHg3N$c^4|g}Qs;hqD(xk+?X1&td)CfebgmFhGajL9GzgL1hHNY_J#&>$xJyp$ z{?6?cv(K`RD(uH}6(o#)Bc=}e6QiQkirfG`@-cl|;R#t24ul^{rMBDF55|~hT?ll_^LqCgRb;H{8*M|>zgD^ham|y>KbKC z9sNdjJwabi``wJ%_}_$OL;|o*$<4#s+nT$EA-$;KgfR38iVXS60ljkJ=~(=tiy=*D z4#Zv01>j~hb(QoGKr_rDphF1wHwf(4lN|_+xL#839AFEBf#1Ig`9sCQe+jzk1su6dSpeHUmbsQ zT~Ljx&0;xN1;jH0)^u)7t7`$Fl&(@oUl&PNt+pT- z%+sb`hi2;!b8i!$)0@qNk@rQfOFg|Y+4Oj{+OK57LkzH~W!$Vi)3{}#vq@->)>4ov z&7GdWEF%TbZoSX%x37bL!Lnks31A|p;J;-xKVndwQrTm0#tjq7iT)c%!>I=|gaKUZ zUvSb-O||CIeM7!P+XB$%72ZB4M~+%5g*z5qPE zf4qn^i5rUtAYP;f&~AFAoLh{B+S6Q0?7ugH+TzW54q zWgk@@r~hWE2CC`3po#u2ph)$C7n4|lyJ;JsgqmI?jLqss^2=dyMT=R1e)A$ZphlC0p|P_#1OF?`ayd7f$8_O zNvHfB>9OYF_M0?-ZOPeFfvW9?H=HFW*o}_L^uC$P)t1kJ3ghZ#^-k%1q^e3?}5ZY$alH@fI#!NH_Rp_Xp8%9BF9FXgiRN1lX$-=)Qr(fR4rMS zt!+>$lnp@7L)rLoLDellEbe@|FbBfQTJpn_7c{-bTRrP%d^dw3S4!{>8vtTIM(Z#frP)obIh#MYq!>tw=ss!n`sO z$_sAV#k3oS0p(u3=NBv_d%Aold?#or9vp5q-g}lp=SIWK z={D@Bj$2yP3n+E@cKdce!<#GB7w-{-4Mz<}k%ZQe5BbpXqfE2|Mp?_*080KlKr0(O zx#g}CAh{sBFlZUR86D2fqGkwRhZ%Tu6h^F4lx{TSwAJk+@=|Wz=G{=YN{2nwOOSe& z->RZZ?~X{1&?GZ87k9p-7W^O|FrEcasJ%(^;JUQl(uXYk{9L#<&ujqH(m2|ZUk&k) zEnO>gz)y&S?k=79+I5nvZ`FU)t(igye4~W>F>q&9wY40WjpYW@VtM;a7K1%P0K@J+ z#ujTSMD(M)k%Z7np35<=2=SmW!=+i6$mTlS$TxM}=)#|v;j3Yid{cafIuu&6Ka20m z#(*gtOX;>A2Kk{6T>m_ zDb0a*!%--HQQOh!gBg+>vK%scefA^t_`JDIT}YOU;%oYHKYaI3ZKz-`D$VER5Ag1h zvc{XPTrJ%Pj2N#M0@Kh9+3I!ulWq)j_}Rlua2p5|Xq2 zCA#m2loYL$0)cmR5DQs~&k6uke%$1TUATE;n;I^{DU&^R=Q&QiZaGcba%}VS`rCOg z?zg=TUFL!H-She|Nlz3YemEE|LSraazNm@ZmmUs zAR8(|Tbvc?A0lCJE=E*!1NOWFgk#!gVjR)ub@2kT%{nbef)3Iz{Edn4Um zVhp|6N^(T4!<|RAf!{)7q0#xEHrf5x=7P(kwaUn;vw39^V>uEc#xRe79$`vI>)!gX zR-se;5&e>1WJHMbe(C_0u#jEOBrV{^{q%f&$A3p|EIor?RI7-23NK*i^_Xl%YL{o~ zHJ2UhiTt(vwJ_ovPD9Jysal!}tt@NNxquq?@g~^~t}j+Us#SiflHOyYWAF+5J)z^7 zUo#KQO<%L_tHm8t2_8WEMoi^&2)ii}W5F(4;QyD#BYa^oGqguc@$EaMx8oVJ0AhRY z@~2}Y_tZ14Et`Ny6c(1ICa8yvN1%J57l1Qt>HQqO3saMCO|R90m*a?_fucDMgYR>{ zf{Oj{tiyYq{VLe?51vazR2&cUYh>Z?1$+2ApCo=zxC|~~RrY=numLzxn8SU^LN;*# z%CpNvH3Dn6DbvVDF?^x=a@6B{#joxTF6ZLbhOx~ucxv&#uJ}A$89A-F4W7nsbc*g4 z=4XDd@E>^fO^V7$WIz9Mvc>-xWd*-uOhhZcd{VXf#EDi}R5*`(62sq`A$6#Lf_nhX z5!UvmM^8iaEBxTs!0$$z1ibyS?oJ(gK8&3SD`Li8fB;U1&W+33g8k)oDYsrb;R9Lc z&tre;SA*}_wNYvct07u_KP^Kz(45}A^-d8QSu)?vgb=MW1gP8=+yT*x{lBvlm7*(o zc9Y!x|Mun(|C?dE!-uei9r8cg!`KG`!Kh>oIkY(UXK}=hB8Mp+WDsMP#5=5tl@1HJ zf3e%|FXP8_KDU8j(@J3;`L6F{4j^rtI@LB4$`~Lkt@evAR4)#tLS#iL_0vZyEvvKn zvIB6Bq!4T}J#UpULwhM5NaB&D;qznL{STlg`!Ty7 z6CF7nc~QE^VUf$!yjY!Ro#=e7@^1HQ+@O9B>Ef(>}mn{6oiz4wvcWkE#+SZe?}|Oopve_gZBed_AieWeA}PW z?k6=8)ApyDGoFXsoXT3IdS5#9%F&a;2n+-YAbp#LP*8+`qCxqH_nir@J#zWoaR7f; z!(5fzK(ucG@H&r4UL&K1B$gu%Sh{@W#s$m-cUyIu0}4Vs3>cR;j8>PO9wM$ng?hIM zx$0w$I4DmejOt(RtQSNbupseg7on8O{L1{Fg>lju_*ABdkTV$E7=(MCxHIc<|1<`w zikD`mU=olMkPG9+<_=C6!y0n^wEmiG#)*({T<)KK{o#E|%3Ds8m(*UFC*EShC#)x| zNK>^lPNxC`iJKqKnDd=f>O_?L`;&WUF>+K3dv@#-+;H^1VU5TCCprDp-Bx{sR_17g-W_(TY1N#IHt1 zqo53~zClyV#*&){jcqo?Y9ts_14jeL9p#rtCjsPvy_!JaQ1DQYw99D_m>^AxZ0yxq zXXZ!UB8w3;#+d6-kt}wa;@u-r&{G9m5>({gf8o<6tw2X~4&W0_hXVf`8&rv>p!cAh zq09yA$TTq&$UgzlVC+q_9ZFLj#mZnD-4d}rkcCO-*JMo{)A-SE09IZQLT%zuV;`_W zi>=d~?b_43YCCWztdn6@`c>z1q=`1(Vy;uiGF$bf&=Nc?X6=}4(I0viQHe5z8k zpJjBiSQPM^kU3uBetPLVSD;+TH+}o_a<&@tnYE@yPk3FY^0~|r59eo#v1^P;$8h3p z*K4lo7yph1c_b3w0ixXp0dw%RYX^h1v||}Tk;2*!YwH-83@8b~L)zx0bHmoATuzkj zTNWszUv}MmN&6B6KQM$Y@)o0d{}m^X(HpGXRKq*qYC|3(WA$u1a8LlJ!SNiJzu5~+ zWPVvGzCV=n)Q7w%sIO!WlK)_rgp>lz`|sN&%pZIp1Nj)vg|q3pu6%jIiBH;hPMEd) zrmn-b+C>fLEjH1OuF0v?~GFbzAd}HoOBX zTgPXv1HP}GzdUfSIyU}VVsQ=JtOMS@e`a}Xy*NI&Xq?k`L#teaPo~2*p&E}eed|DMB6nxA88nPTt8XXVxT&KzN_eWwJ zGl)MjMQ|q<=YUh??=yrNN;Hdr>PdBrGC21Sy0JTyT#Q_d4KT{Qs$1#_HscJ{Du$)h zO}m@2w03;R%#w`+ONL0whnn?P)3(nyE>n;aOinuQcp+)>Ftnc`M!7MdHAUjgs7uPL zmuhjJK`cmI{n{64XghHPyQOi8lx3x-9_wHf3_ z5#0~EA2JaB>*db!&GXG;4XL>RJ|lS(-Mzh_-@??Y2Xi-(i-UUZVg5FQ%$b<{RSx&= zudpNn-e)b&YukRSqKz62lH)BRQAQUVY>9QI*G8Z@Vx-Pn1D_mDME5zsvalhQoAt+KdFJxc5^pM`r2jt&1x8#7MKhHog8*6Y#0K zXqBrh3auZ(2sR0S7-butjWIc4SX%#eO1LT2fUINO;-)4FX=&qa+HD#yDI_<`2^-SV zEeRXbx@Ft^Q%F5;0k6-syU19XeO>ebhrbUVw7sqpeoV%8BEX8KC6o8UwM4JvZR?jB zpZq=P)WbM_P;DB`X$4#FXtgyn4;3zj9sSxYfL$Y*iAelr>*UuOK1EsR<$H`s_W`2R zPa!t`ZqO3mpY)Ppq&s3O@48#ZTF1D_r^1LPS^{sIZ<~4N=er_cF^kBG$ZFAZWOHR- zxoQx5nXpNu0xNzeIRFWpEw?SVw1`G!8GbEAEZ&F6Vc6rtY;^_IFsqMCD;!8pu zVgRM4_JD~$P&FsPoF>Ly=-g}D9f=zS2xL^N)NXggm0R-K+g9QhztIOM+~hrgfHG>v zL1~4V@-i(AZaO0Ew@v0%BP_%yPvQ{&`X^zwkd-(_qc}E1DqtAd%kK(8%yd}RW#^!RymXJG7GW_F#Y#r5Qo z!j;8bp-E=TZUZC$?glpAW{Arq)f37UhvBInq9X2-YTUFjCx6?zQp_B?mgz>0@X^cb zFwcXk1akWX!w#iVTR5szIFAWp>|(y5wm~Yv@vN|0uTBJ#mWo9PJ{Qc94h(&pw zs-_YB;!u~|H8tCTe0-&aD_q?1t^0{a^1fih(pgu^5DqH{FZbqXo4^R~?)vt7&u!>hdtaH)i zclAD9Ty5@lf;E4k8Sq{I+3PCsssZ3Khi1-#@A};Xp)zH4tJ(1#12R%QLpCL3NnRhF z`lEQ}(|(b&h_^OC65lUvl>dfKo)HKbG+9W##7Q35=PJ z<5A?Z>3){dEV26RzHsS59sN!SL+CK?ccGt=_l#hyUxHQ&5TD4(5q%f9I+Vg_RZ-@j zM(da{;0}|6AweD{1hrfbQ4yrU6@z9BtJd8mhF3ElurYMl#s0k-Ria`5x4EHj7g5W7 z>Q^vvD(KWO6{bs7;86^-4Q)(ns=z*px93> zv#aUw#{s{6>O8@?E17wY7){}NA4~5dI);b{m`R_H_soafU>+OzEd2U5_uSxx0xU;-P6vx^{YnDa?Q-;;@wemGIk%Te^4V9IE)#BA+1vC^# zomiATc>pWym}rIbNvP>$H&~wa0VZ+!*WQ*o9p}f9$)fZYWw?24V56b_Tof~1f_7q1 za1{@ol|+|kQ6<8p-wbG-VSlHh{LXo8bgMXg>8~WWwna-1-|fESGdPAFs)pkkzXDM} z{Pbq&;VC%Hb2&^P{-n9R$@pnLPfw3p`d`Deuq{UCKTB zbnWNfC7^%QNG$Nt27ZKUh&$!M-}oY`=H9+eJCrkD9}&r8mVkrZEKq%pxFKPba}D z@PsgQZHmT783JTC@4J8VA8l(E1e;i{52Y~D#is29qAOdu%^rLadH3!yXJmB&qkjY92yS_R)A5V8+PD1c-(d4zn<3&HQ5_%}D9U>&UAJcjxBa_C(e@6J1Wu4PR1T+E6jyGyd85_cvK?u|Qok z56&hi&d%~%o00ICQzckX z5ombF9BlV&-MuZo-9El8EUJZQEb5z&rw>4_4UQoH}w~n48t0l#n zp(z93Hv5?&>>r{xd`X^rWVxru{+eBI{Fmu%-8b`#JNqJXl2y9XFTe=?C-PU(fN%QL z1To5##bS!^3LyGuic){s0D$)TLF*Op>*(`L?Y?vS6ZU@Pb#X5Eh9Q|?xJ3@t}75x2-jHKkk>T1Rn*6>l7GyjdCi%ZxR%{eb`n1U630QdmaLuftwvs(@^u=~~PrtR$=f{~N>& z@~E+pAbzZ)_eDt6T853i9dOIi%hDP62a>}~{9fC*3P#iFTO3-vodg6U<|#0;=3+*e zz7fKGIQ!=tuQ9=SPaVQGn^cDlT9t&>s+tdOoK3!$*7)+o@=FgJwAhO5!<1H$TRw;cffU-O1vfE(zkryMTXlp}vTxMn7 z`=@fnt`FZS(8M1n^kA&1`rd(2DV~0a_kDT{ALSNyky5kV7T>w`zJf0!^SCcr9XZg4 znSu+v$i^3A4Kfvx0IeC*Li%R&C_6ku27cR$PQ}eQKg4^0>>H6&|8-b}ngV0lK_aA( zfNXuFi{ne6GCaHSx8;zM#PX)>a@+QuIaru=YX5dw$)e>>w-R?eXf>%Bzmovy(04wC z0*FDn80};pq!BfdKsL2H7SjtcH$?!8ppys)u%;s(3Tcw5wd>_x*NQpc6yU{=0v%^f z$o}ssu)@Upq!@%09jM;=l${!VDHJb-R1VG~kJwrGe2nx^FwsqLSCP{>Z^5rk!sz~M z{h5m|&_h?SG6V6Gjxs){e~EHF@(H5v38L+*sX6-vH0x@u1H4uT?gm8O0ceFM2){aB z3#Un4KV&q9w?*TAXJ`SSf?_Y+zIY|yC-JVkI}yF(^9jv+?Sv)<2izo^VJ=fG1))!X z|9TJrM_h5sL{Lct1n`2P9=UGsr$3pAwW2J-N%AHPO7xA6JTqEmlLhf~G}7Vx$)E4w zf^(6jaK8owECSj{GpGREoLEB)^CChgB(+!vZbKYmC^K$b$SJcKBg*e38_ZF^j81ul zs#BX@2qC4wmd(1sukXeXX z$Wdt8N8Ut7DbcxE6TL(onB4q{$-n4PhB)FjR@UN+&NiWol&-4`Vd-e~J>$1#zg~!& z(`bgP9(fp+6j+w%KS4l&V2Fb6q6aa5D67ROc60NhV}$~mrT}I9^~$%OQs`v0XL6kc z;|mgjz{Y%t5!8F=C{_q<^}65sE{e0gY;R;xVae7h$$qG`J*g49&F*_V@=tyG>WIT_ z^PA9Z&Z1f_#kI}_;0jtsZ71}=7LyOnKo>+?+kn8_#Q`>J@Ev zW@~lFJV+Ho^Uyz#u8Vc_bX2h(z&<)dXn(B6o-wElM3-3pK*^-{{5U|TP@WNSyS8oS;a>(IzbJOnkJ|=#CF7XGf{6XZ!PA) zKXcW!8|z)2OPzuz#JyaRHhAYSy^loKR*TkQ#W+gz+gvB!JNKiN0UnBi#U3`l&NSIt z2y~)mvU=$qqy?Ei?&zqBODx(3PlV-Oo$oo6N&fuRB`!eC7kKyO?#o|)Tn0`8Mw@HI zaoWGw7b;wydvC@&r#q*u{5vx`GoI0l&Lz{i_tN~zI5n(lZ2hEF7*vWM@TeiI&(?vu0Sr&zqv=$F)nw8hi%+;Uq7GcYKLj0Gcd~|HpTBkG5a>8^Dz#d9LC}e&D z9DYYk|LYreyYmF}a+~ht?&a=BYmQ3GMJI4|CUmZ1WP_4~`|4Wp&GEHr?)q2{o;Q+)gZKQM;Itf{W9Du;TjCThmv^1Tl{XQUB2P@d--QFIaEsp)D<+|D$3bA0kN~K`p(q&mWFa}x z5kd@iNK~#8M`4R=WCP|OK57QIsS7ZXA?U8t=;nB_zameJ{`Hey&5M480SK6UZ;|&F zCbx597kqCSq4*w=Z-~nlsUd*k7`aHr9dKF)RE8=5^RIK zfYadruyyTVnah!iK4 zCY6Z9MhY#3RL-5uc^cOKNFrukjn4C1sfBE|#vV)i+>ozGx~aOU@{kYPjo8UzxRrR6 zcxY;(X*xrNl^Zfv!WQ!MA@Ij%y{%Nso`=Pvf+YrV)$-SiT8a< zu>0}3UaVY!G3erGcj>oXup|mGv-Jgf?{U-$VJC{^Ou0s*sW^|&#m)GJ_?kky_$9hZ z&<6carLUzi{M4@RkC?fvTM*pTJb*wKMgHPP^dSn97W1ffQt=khe!$5x#XH;{TG)Rn}Qanz;mb z(Q{|;SkC!AFMLc?P|LPfaD{H^^ zrGUi)>3jMXc8KG7euFZ5`aVQ~>u2$T&_lpo9X%%+zETa5O;7GJ}@J(_9K+DK6- zY?5?bmXh47Da}eJ5eukwU{?{FVq{6 zx7{gGzEA>vN;wz<;f^^Eq+lZDG~DJ5TAGjBEdd6b;~uS9w=?D+K{{ibJ zYU~D8&0)=YoHRcNt@UzwvwhGLyZ7x^3zFXi>vBKSzw)D1+x2%4-oG|Cs;{0`XIp{r zt9fC9J@nddM#3tG)4ygOlD`u8&6=8cunF1F4D*_=@|@2;06T4!ygb^szF$vo44kDp z@!rGl@GbSRxM-}QISSLQKr~Sjo-yBk_d@wmz4phR2?sGUuuqguN3W&hvmn8FlzYDb zTM2@VzQ)hCyV`70 zDWI-4UJL)7deA$9q(K?e01|qsp>JIz+ian}#`=$)%sWrc=r>p1j9_f0hGjgE>~mxG zX^*HEWd|lPr3Zz_|7f}khN#-MUBGmgq?ELDw{(}l0Mgyv(%ndlGzbU+(%s$N-QC>{ zd(HEHdyZcqILw;+zRvR^efqr9zuUiyCpz|+alI&&ZQ};agi0mdE)zmKs&AF`%)-2X zde0Q5h4}*a1x`!s>ut&rs|s12qD|I<7wMkPNaF(MhV{Pn{<&2y&zAsc>>p7uyy|0# z#T6;7@BynQxU2q&CD;NYUoo(HSgjrUfp76ikyIMvx!+1e*0oAlQlU1;@l4&~e(g|l z1?bSvrx}Y_h*A*G#1TwcEuq#vZrE?xZ=naU>EV~d`L|!YS&6K?HM}}9lDa4yWh69j z&NLUS38)f}^<_m1JyT%&sz2y%63|EWYM^DdX11;^lY)dmLKB~E?g6_RUBUJpM20ae zB+#dJ0N0DQO`q;(0{43`|MCU(6Z+7O>3{-g#pd?%+i76gpKzl#fG~j@OxX4x*EhnZ zIRV8o>iJ*C`MuWqVEV?7)ujQM_+Z&UTWt}AE^-c#i78WnpDlk<6{0ClP#vNJwW|SK z@l~zB+kpL@(!mI=s5~Pwa|)~jRJG`Ur&gveu@&Ysyn7WUB8*ybMy27_v)>$|lbYXg zf71%#{SwENd7)5w@at)Nwl6zIEjhj=QQgHf(00uA{tFQ2HJJ|p4*1mGW?l*(RsQT4 z40gr`833_xGp2uoPEZn)`T2_ltzyrveMiAzj5R6;mEA|g^rC?;C2EBJ3UgRXy(xlkI z{vG4F0Ch|FBH$(4NY2*43_y2c0{{O<;N^36-2+ZkDNLn?VjAWc$ICPI1=<6gR2z$Q zAh+Wk2OEsEH^vsC{J+F~6DssomiVXCEO|<>n*A2~L`aYk{Kajyu{Z|O65kRZ$5Shb zXc1?qjrRF-0|Iu|mI`*f7LjkMbb{LDYF z|Av9>kkrBgN0SiY)R{0P(VlQgIXkcz&%M5m7{xzT&(p@o?Or^jJOLtmwyE`|cY!7A zRldUnh_)n_&(h0E4u<<7zwzoi?|-+Q-@Kw$Y%YWv6W(=nGNbuAUdYkdX|7Z?@clcT zy|ePd$O>2NVJq2}G#^^@dKnpi2`nA}|JXiQ$Xja#WiU_=4|ae;*%GdxTijJzXxCs` zgVsdOA@c4M)>J&vvCVM-fk29@d`(}3Q7v-T=t6MMXXH6$_%AzV6buDq0{sxqE>a5N z2;CDI9||1TEzq0(xNK#^Sr?dUYnHxf5XB<-k%IKe=%)7|k|~JUi3hNt+9V+u z>5cn{LQWzj7~{Poy4uUPMSNK{O8E?%KsAK9OQ9`uO;3ZI06V0Ez<|zxei9Y|i-XMO z7bMwAcx(3^M~l&>w&E7%-#h3v?C2fM5_uXoKN`|Ds7^#1{wD#zW}?Y@b+pJ8q3@$t z&T|Cu^eU<}wQl|*>Y8WAbBiM406`U;Qpx_BkFZNoWQZC?INOF?Tf*x}mLFHj@6oX< zXcp%YBImeLX#$%N>yK0hWvuf9UL8O;PwOhFp=4K7up>q@g)1<#h<(d=q`ebjuxzkg zrILiX=#D&umQ0Lx77}<9c+;iP&~$m!SByippPLcuq!%=^S2(J&tO0UkU0UITlZo_+AKia@xKER7H1m2pGa-I$lb2kK#rKpb<@2N^JBv&vSl6)gj zvHY6H3SuiU(HLZ*X{_Cui`ORm!VbU^)duTuPT%Jmw=IJz9#Pq&y%s((u8i#!+^bT` zm=XKQSS7)A);VwYcQR7%X3Mkt$n({FMn56wiv2P5CF-g(`B&d54=lOk&j#rXfeUY9 zr`Y{Z;{s^C`w`azhIM@Ga4;fIlbVi$AKc zNYx?|ji|zTjbc)QOkdwHcGw!fGIbO1Q*Cway%$IHw{vCxhMQa80SK>9ong8yM;xZ& zTFWwo9@GIoJvS)9Jtkh$??02SaIA35VDZBPLNNGvU7b$oE=sRUug78iaQtxE5d*lP z?fbq~7#@v_jXb1WRt{o(B>YJD0Mnx0s@{qt60KxBb1v*5?IGQ>aOg)->eIGF$kR)! zxvaKP)2rO0S3&q$LL(v_>+bnW6sN|$A*+9wMuhiI^p>$>S+5dFGYo6}sR=FSz+aUN z+r=HsuT$+GtPX2$mafTeS7+R&?Sf1Ct3C~XLBqLITS$MyusGCey2H(o=K1MB4lSEW zvB@|PLtsC6qcJZ5!|%Us$+U#-vG5;lh%OnLq(aTZC6 ztQOg+)@#|wnX=K~%ZA279(jSy|0PFLhNBHCtAtsaukL2U^}_<>dSmSH1h^-ed*E7U zT?k(A#9lXek%Z^x6j~thk52PP^9?wrjQg3=@kJcG_YQ6R_lcOLy1Y2%Iz-kV6DXyb z%>cq}Kvt@71h8Ur)7XJlAVl55&d^p-uX0*wn49#ruBr%)c85wzZA|HDV(9=-^^Sz~ z0dIi-DDiwLKywMUU%t?E7Gj}*ve(}`e_2Ml+J7@p1S=C8p>W*7#l5At^;#&Uo^?ly zMbzI0OXIbv@D9YOzceyaJjvc99`F+yx%1%~|3gnoG)?+_REL`&F!X7c8pF6(;}RQK zh4HoHOT}Do)eS=}dXfZJvw0|SSaV+>bDDk-upEIjJ*aVX<#T<2#}L2i-ZBFLqH=Q6 z3%*>ZQfG_@b8yNa>n~$wk)b~cVue^_>5=nW!03gZl zCC(yIsx+mZSKw=bv0;yvvwhvBf8Ui3$p^;3uh56f%kAxcF&ixa0ZcsfV1UVe0LdX1 zU^}1pM^^9nmibD9Sy;dp5eks4X?7y;9}C>2!BQ=hO?09!aFylD`<>JBlL#LZ0M)4K zT)d|ik|EEV?!+bH;0UOEbxwy_`|nj3$OcU=@iRwy!t8hi>U@5!yfvNF*sJd@Y8S*@ zpr;@pH1nSGhIczBJhxO*tJyBPaojNv37zu`fJJ&^axgf7@ho_5Db@qO5CsQ$_1WVW z5uB_*UZyl;ZV!!;*)pMjnD7nOYmajsrPt^1x19EdWd&yI=)CL$$I<c~adk^a&C(E@+Y5<|v0xN|blxiSEDTs^a#U%%=7YpGJLMAo+d*QB8AgthvQjq*x@6L;Shj~Ch?mZ{bPNS-)O7dgl9py7Iq2wxJk5;8xNw2Cm z53aVh=oqbnBT@o$BA~J)DY7$))p+D1LNp5CJHFGN*U|yC?SB1gTrPTb2QYH%XpytyIBYV8Z`&0mQ++=&zr?*cRlkL2OF%V8#e9 z{;iTR{YC0-f3ddFiZO<`AM8xFM72caiTv?*l!7E4U(7S*$LHwRKD+cumybK6S7sh~ z55B;4F&`>U`@aW?UiLT_`?=OcE>ZCEy?t$ql}g9{zICx*mh$(VCQzeV>nQ7 zPvJ%8xndj(-%+SpS=(E$W;4#gw8s0a`XN{4p3t0E}h&Y&Z zl=;Fsw+%;?+(DZ2CDzy?mLXF}dCMI!uEKRmrK8`E+fi{u*QhV^<|Tsz`n?1C`!#Lwdr&<3VAzgWgPLLb zZUM?SI67!swMBQDQgyBJn#^YJzi0BR=}mY97N|9F1P9bNSWk#Ns;A#-Rc1G2Zvfcj zQeZm0st(!!LTn%#r8hwYH3|(Na}_@cU-*#yU8RY3)rP7M&j4;T8y|*O2Q9h#wBcdh zVe@XRbHNf@r~LS~z3L6gxo**E7lqghL|!mJ>lA^k?S^)@3F5&<6Hyw^$&?TvYu0wH zKd}RS&pr^Igyie#g{YJ|`QSzRWPH6S&y6*+3e9w&yz+koV3zP?Q}@Mb>zDA<4GmsFimdq4eI zExd;@8$p6b1jI$3o;Z8=n48|4#uyzEsE91c_=4DF-EB<~8+0#r9;SylR4`OtOD*F7MgV;4#d zx+r&afdC>w>9bnkgR(bmSs<`#`U0LM>k*|__O;CBedW3`QwlDL%{rG;!x&;B>upQB z1nvcbMV~{TU)mqkI#1sP4^Td@DhDRKF_U*%$q13P2TC$)TMj2aVD0C+OSKJVkB@ z>?1NxxHm#5WKfpE=FQ^}|$_!N( zG2FvUX|%#|b9y-~L%}nnqW4WIXtZGoVqDO+A84==5Qkv6U!-MJl@q^lx9ag0WT=cS z(njA0T2K=FkZg#-;tSC&!JzL!(kU)0WpTyUxGLeNA2-Uw&FVIlRnMbSEq}Zvh35_D z+i*NXHeY?^mhpJ!c1HwX1t`uq#yAu0Fg41ZRc#Ik zFVm?OoyQ)CQI&lf*QUoJG7F}m|7vHntjNJ>OiVtUsW161UyBhuGc)lR11;VG)CldL zd8fes9gx|ggS{e_STVavCL6!Krdr{ga8)p(%$X7qSF*AE9d=1GV#lJb-e43 z8S$pS}HY}AnQx>cL|G+PvYLSc(c--K|^)rHDMkp zVFBO{u~k@&hhW7A(geaG)Ll`#pcS}A)D=mS#ht1_(_gEwdh)<19c6mJlo966cgxa64n}yE9Ui*BF*PAcA_Rdq=g^(Zh_xw`z;d8nHxhL47 z?W0=Z@QbRz7F5SS&oNWIhC_>m@j1l@bWKfI=NI&w>Rsi+53?7=o9ZIxWp4A$DuSCT zzyt#)ZVy}KR|e=t9j4^rRloJchV<&u#XTDq@W#eH12qo%G#p!m<7I3=p*}J3@#zpAO5(hONo*Iix1*;G<~!u#K^Uk3)__ z=mQIC0lX$J@t1OvkQ_oYFQDu6?8yVkTtf6r}>NUJp#XT_TR6~RsWdK9rfFAm8a-`%T zTTng5M_X5ZMOPj;*?nMm<39zm{Ko;aWqVoYPDnQtQI!L8`U#9Blt3){kAut8?4f!= zcgSC48NB$8mqEY}Cs-HD8V)UjkmB01xh5@Setplj8*fV?#ZN&C(l(S_TV0!@=V0K) z%~7u{o)bQ;^YhimxAsbYwL`q{+ESf68m@jn+XwV%r1*ex^)82LxLeaFHXnTKS*9Z0 zZ-h=|J351nP$9L*)_8MuDPCJ>$-0HQ6HFF(9mz*>w|Syn8Ns}W&ZM<6R=;LGW4wQR zQMpuHgbuhgsA19i$fzTi=p@XWP1Iqv!O?3qGSV-v?Hq^wJ}ddCPpHAAtY4l8u6*qkg7-#*H1O4aK|g2Cg(z zP3&4T9Q~c^Lh(lNMjgse2;htWRFb021f^sd`9>^4wGsMoKRqwaz1>&dF>;D{GYIba z*P;RM&!C?ITm)M(C7tupq-$8`hEOhr!%PglS`d+rxP4!ey@Pu9USJ8}X zpUUdkY8fjsc1!9om{1_9>lc?B*6U7OLK>PJUAA#WPYr9sX7!9{tCgvNUleEP91jY7 z7r-~j$K`HzF&W+u?j7Z=5x?s^bRE^L@($0aq4b*;yiu(NqiY~|lY4z&ycyM~td_8a zorT?jM0ibXP3(97ff2wpDc(?s6PdfU2Oz-wFMzUVCbAGu1-+$VWD{0$UymcKMcS%bcK!2W-#imYHMqszC{AiMhbB zNDbDhc(e5xcY&h~dfG6dR$Z0G2;OzC_t5y{N+D&)e%J zuZ?RRzyy!xE>Tp*$F=8%*k|Dp-0EJNdxP!2ND|hPfIvN^@_*_u9$J}61(jdk?Kfm8 ziSK5y_&c#WfW5~Bqq%}ng-f`y@eNx_qNSv+-9&d+{-yms9>xiBi>&JWidwkUn3o8yzJ^0)* zC3QdIsO%3MbpDoU`I_*@opq~E{5@tExxE&bkOR~^SXT|*+AlR&ONh5J z;j0AAoOZO|G&BuOpB(v6cbI6Lde2{LEkjI8=+&}<;b88fwO zXfZMf07$UW$OL#Cp%V=No(r@q0Mxm}xrBXXb7i~;eu7A{#Fhpd5q%l-ZZh<)FzTSO16qliv}H zJMq?JP%}QEa|dQ+H7!_0XT0O?2cJ!ZNPm5uGwvPf50J(w%*po=s_XD9L+$?JzyVn) z%z#mDBoagqq25U62lbf#A|C_$*ygQ|0y{+WYx)$`Q4FN_O%Ge(1bT>y%^uC)-*SA(W}-to34^rbfoed%1?NkDf2e(+eIPU92=gejJSx&L?i?cv z={acaPYXiu=aA1K`2n7h0Q!I6q+4XR-yZ-P8!0p!gm;gWH_Z1x$hr=Mhwp#m>xiaK zh(M=7waRjZc{5duX4Yg)6aZ*%l4rp?ACy8VmDv1GAq}IB>Dyf0vjydXKDUyu+#m{+2AS}@aO->y+50L zYW`Q~S2#eZHMWKax#G@ixgKz)bNeL6`%G)@w@XuY^2%QC%vaxBVfk1CbcLW^(LN@4 zBaz!u0RG%;PKC*lgvNJL1;5!R~6ydQtKiWre`$4U9x7ok+Zd^aVw6R^x zT+dv8hxKa_65Oa%Ir{`zDosD7=I{0gzyc#00O~-0TYqVPM4jlf-mbkD25JL(xEStc zG(edunOKAY3g0p7gSM3ThY(AA^r$fid*CSN8fpE#n1HicriDLzLPos8l7@NR=df*? zgna=#%wv(F7_{UPD<&t)WBLob>jcDu7LjTsvSpWJgrey^1N~e9ytR;!S z56|OhgZ6&)dG)#POgu01cJqKvSXFn`U;Ks9M&&JMfdsRT+D6zCm?!+SY6dl5qXMTL z_~&B;8L1U8KMA>407feGGi$(FIXN206>nq1utDJmpj_lVPI+5qzvcj-GBv@NWF=eW z0K>{J^tZwN*YNoVd9?lf+K+K#wTj^PgAsf3#_$Xm6I?!1OFSMt+oVi9MDPs9`zn|PWf-VX#BHV1?AKp zi00(mLg5Abz{ez324jvMA&ht77X+G>Zw-YPl5yk1`=$$-;iE8@g%96K;HyU%*yTux zuwoGVMJMYe)^UB1L#B}n@D#$7b7yEcNw2haY6q;dGn5r*3;fwLHc`UId-u1Tv-wsJ zV_bw^fJX$oeyZeom;8bE#w}-NO`sRL=&p;uMvR2slmKoa@1mu z#an859iUrIGhnAGt|J~5x^NP;h=lB8O|&$3W^dI5CvL5XzAv23WsIimx=pr zLj9Nx>zpVQ_#*N~YHmP$plvK5v={K0@|Ys{F)B7XHX7FTOFUXm)jx(9|EI{ONGFV$ z&sJEqZ2!z>*q6#T8oQmt)DV`|YuXDHwP{U{;9WfrSxQhBPwym6AqMn!%bn7HlRG1b zO9ux>%<^aknWFk4U(l+V{7XcF>Q4}r~a2@ zA|Bwur{1>d&Fhg@`aYEcoEwZKRJ#%-Wi&1UtHbLOMUOlA?LKkGZi_l7Mow?l5R1Ly zpY;vmvn(8PRu!DkdIg>^H4mSWDn$I+qNE{Aj2@EwU%WV*CL%}2nKT~w_b(!L1%YMn z^u-g(*#%b_oAwXIh`e<_qVEf#z}920C_5lyM;a+HWPg`AjGv+c?J-{`Kay$i0uTcw zClHP>1U>-*aPZcUX50YvHX83(209!}1Yx9XRDjixx&pz3C(scz=>EDXYn~5QK8%}q zt%jImz$R|d0RP*%s*id!e0G;H&ZlA!ER-t1`1JTC#WXLWT=Q~a$(}STaeU}oI-;=w zs)b;^@*nZ|S@#^m@TZ)%2ApHz1$bb;tK&@F!YDKl+q2S`7lNJJXZC}Om&PO%F&jWJ zTX-J(dFOIp=0nnEs%bUK?4NmqjmmJB=s}$%VaU@{7Nv{-{ORv{lCQQWyR@RbqP#tV zBjFZTkLr7WzqElY0Qci;l$9j@&g^h;G9Gkeu9MX68u}kPKwtKZ`Vsx;>B22KDZdcE z&e0t{oFx6Rqx93c}C0Qp}} z$+^P7@6a+LDycyw4Wz@vh9UNSgP)3mkMsQH;I>F5<^hfFL89P@{$Cz(vsMrWLxn*T*zU zP8q9s82oe7mgLJ%2iLccPu?_#dQ+```3}yH0D)|ZsRbk5TI%XsbRMTO7gsfxeyY&J zY8-rqA9hh|h)*!QD&R1;MauK$r;Y<03mgkrF=Xcx%jh-HO;v}A5~9O^b#X}t9vBfI zaqf#l!Bsbkp3&HJ67>%)d27n&L?qBC0zt3U+bnE56$W8tRZA5 z2bqPwM&CvQ6hODBMdROm&|};L)@~o@ zcwF{oQh(KVrT#RR%uI!%0%8q&%#}C+&txE85bwkQTB;_rXI-YPPCz^{6`!m^(Al() zXH@Bo6&%p1oKz|bOg)%7W(n&&H{3ZAlNL%SNB+f)$Vnu5*Lal*} zG*Y97T!(5wzdMD%wNS^Gh8SpG?Xe_9|M=n^I_>|G ze0~J+X`eae+ep~9*tY2UMARZna5Ys(bIl}2qr^b`HSQKl_B4m;Q{~@TQXb9PG;PFO zyo_1h*J`PWRmrYwb`}S!nS$GC@&RzNb%{3gi*T|fn8iI!LPERQP9R={ExgOf2iTF^ zJ*De^$f&!Y?Y8pYXYnrE9bZ-dnDrkIneVV);q%=!BFy9-Dc#ZxKxvX9XWJMoc2ot# zy{o>dKkAEYW`+3Sz9DXUfF*Eq%t#!O-}-C_tZfS*#3BRSN=+>7^IKD&2xl^tyd+QA zCk~z^*SW_6ifC0;igW`t*yp0K=EP-F4QK;%vKA+Hsr_3|R24LzL6Sza8dgh|eCZ6< zjJB0q)nXbp&2AM2^Mt|*aacQYb0!ns3r5|kzFuO2P=6JlOyn_wdJQf!Uws9kPE7%7 z7kAfp*GzEd>n(oQD3FS%0DJ99P6D8&L6Serh2#|GzXrz|+uwXKc@SP5A=2sN0QOZ# zx0Vm~J%k|j85|c_6PJ;rl-Un2Zja|z>mhuPuGr2om_vqC3s~I!m<-@hC3YF+Y-$fL zp@)~Tep$^BrY3ph)s2i=MIcT?+$j}fr-zTMu2P<_Cm+(4jHFNJ zjo5Vz))AHRf!*j`NK8bKlq3#)VPYj#7^phHJ6A#*#`Oyq>LK2cxuf)ox4D~>4sYjt zn`_|vbCNK+07Td`uht%xfYxq3-Xl z+49x4q;u?*6zE#GLWz^k`3O;!bwaHeP{KezOi!vlsJd6`ANrX~Q`XqD`M23K>VT$G z(jw8sq=fZF|C6zg583W?f}+ZtXhGd)m2){;#} z)7$hiu^04Yd>ET2q&$Y{g#9>K42D5M2tbZzBQ)h23f`+u8@CcfW&`RQ$Nr%ha+ZXu zB1EGCTvF>~#edLz;AW6HO9Jx7I&+ELPmk(}qe%&)ChUtNl2|6%Xvj+biA!#T!PKGD zp(MdmwRzTZ>LQ)Ru;sX}p%<^4&tm4ng}F0Io`KxG>07Oc-Z%hmv5{uh^F9V>{Q%&{ zg!WSXQth26Y+YPCs|Wpo!l=g*1TNHg?sOY)8@T6t;CkkI&Pke*O*P8PKU#-QU!aUQ z?VF{?HI^&14ml3TuOmN_Bu%%eTwEgg;i@s7m*gKnX3Q82-SsI>r!GO%38x~M$_aAd z(MhmT;~2jK&zo#4NK2{o-$~b!pB-H07A<~N;!y$FmGDl01u{Y@VksggY+mz}?jdSn zx(ateW<_R}412bd(r(TWv#_V0r`{8Gxcm?KAH>Mu?y8pHJPwuYoBgRQx%xm%5Y!NB zTq9d@q=B!2Z+5#iD~2gLLOlu~xXTS`otA@kUGZ`4w)I#W#<9G=_0v7v-)I@aUtDl( zUrfIb9qiCGL>)=GA+}!Qc zIGq%$K|#oX*i{@qOv`X{iyZH?EO?|C21KF)fX<7Yk~nl4jkYJb7;0ayYXTAn#Sb5P zFe}9wDpjtZf?mYl$kc<}!ra2{t)3 zxgNQiu;At9C*2X$r6GxEmzAUbterNNbsU6CC{e^*Fs|qaz};3Q$_IrGcT9~As1KdWHL5+zdK^$q)4Dx| zoDltnG9Yv)H|Kiyj|X4PAAk9fK11yQt8JJdZ|#rPXQasT<-ew<^#AD!M#7@whf}pL z_SCNR%J#fHnk^o$#!;1HMA#4cf^il0@@KuGgsv~;Pod9;qm$E ze)k->wz;++ZO5tMT_UnYdk6z-ND}4MKuZduz4uL4{Jb=kR5$-(@FtTq^zM3_JQxXd z9nkpwUHNjbA~b{thGB~XfXy40O-^JA%Gl=Zca9Nzt9&tjlp@2#`tbusShI{lU2Q4; z-b@2E!#A>eJGBm^77NXowIf8w40P*_OYh12dbBQ%jX39+7C=vp25VMp zbn{Cmzo~5x4xSC>xQ~bB>Z&enOHeyw>!zxkSN$J}O@1=4F$V(m;%V}>Nn>8wWh(QQ z_sbL4#@W6Fz6A=9|FzK>*bem6YoMN(M2eW-z){SF&t8k9XUjLZR>pYn?(L>L#(n2M zbf2=6_T_w>-BI7PdM&;!pQ}}QM+^L~4WKSnfw+Rejd?@iBm;HK{-w{JlzC9@3Nu_~ zD}iTsO)-WuH>1%&Zfz8(`>cjf0b2A^f%#!^;^G+9{-(<*;M?twB^YV45bSW*Xh2An zglXguuE^nV9&>UVN}jfCeS%#;)$*_%b2G8*UNW#V&|W(pND7y^>t24L(EwFs8$e=@ zF=y!WkRavbe5Fr8>f{CBiRc%UPYXet)>mmSB4@e+#$2r?UbFqm{K}Xs34so#wXgR1 z=KlA*=gw`hq^J8eS<^3Zjik;Zz59Rm2GS_3?fl`~I2v*{_a|yhr<3H(MQ?d$_h+=mRC9ed2;pWq_;eLv0^|nT!e>>}IdD*nmbCqbv?piPXUJMh(S`qt5mp{1O?Wiu6?{Vt1fG-wQYgecnEcO^2lYnIJ8TtxO{4!*DAh z{Ybl8kU)U(#C2n9fdR9I(DGryn02lJrc*I63x<>Cv0-OBKBTUe0v0IeiDarZTJt%r zKr550zy^s`mY^6KFgd427H5|V!_vKAjq?^L*$bT$g=#e_&kJJwW1qo4LW$en;o(J- zeM-7vJVcgN%qy6}+M4e#kJU#X&F4;Ev-z?+)aRppZ@XHLqaft|)H#hVdU!Imm{(19 z_NO6i>r)^|l!hz;V)5sRv@49a(1Y*AD+GQ(l&~bkR@;x~&u4_7BKq0HqwK61#UtuY z4Fd)i+=h}Sr-o+d3WtqWh3)gFC)d`u#9Q@ZldTr_igCY z`c*T7b2lw`kQVjL{eHi4>hONwok$b|skN8*YWjfG=!+9)6AEMqBmR6uf@wqa#(ID& zdIHP7!>euo_X_)v1SYK4+~VqSO1i=XK;u^x0O&r{w$POi6>G?5i!}sY_;Hm!l_TL5 z7+zp2UQ+Hx^ShLNQTJIjbN&=&pjpA70mGZM;~jsUpD2^KjGm(?ku`M=_1^mC^-9ek z8Gpy{p#G%(R2*;~aUS7^+{5+57BdA^5NNmj9B`g~OK0I{eP1z?zVth6|HngW-qghiC4O{s`Lf_ZDmG zB;8>Bgr#je{Em-d|D!%mg9f`~9nV&H1cQBNy%bxgE>MGc&KWCQ!szD%#y?3;whkTh zGIo7PkFTG8rJXLg6O54UVLS#=VHl8EXlfhF68HbFznNO(`v={gQ&%Kg z))e$K^fa-PnGtscA$(u97fNw>DS#LYH!%Ai5;zN6jI1WsRgF0QnIG8^9}I(f+ax16 z#fSCT=uTv$D#es_nABD8q-DVagPYz?ZH3_i9CW$=o){^qpIbhOccTv0VPRjxy%fZ| zKxBiK&p$Hai1B0Bs8Pdr)aOuVea!P>9xh4cJtr>Vz3l(KW~%;>{nllA$#WQhYAUvf z0q*j<3>e+}2fgNP-^NYCujrY1!|#E5A|R1JfXzUA4zu!|gimkg2UVibaMrHEa{y4x zpmIce>xOWHbQ6&ZQ#or~+lKaE*Y@a3&L+3ZW}t& z9yH(Rddg3{Ht7q&K7oAx`BHp@kAm()EdFVl33ZKojq6-L`tOP8A=G|Hp=8Xv^7Qb1 zENx?|+c%E5@9Is+l9f{H+Aq^Z*amO85yrb${mM=5C>oK!i((5GgZoE%3hGzm zv;i2PFgh818GeU6ZqM#ceOVH=TjG+j*>6HPHv2m#1#jbPb( zMU7TWAElym`;_9KcOZBn=+Wbqn}1orychBx`j$kZttMqxks`PP1q@nWA;vKeCYvCp=%?!sKc9wnqj))e!8B1> zOz`p#<-ks}g?;$IGw$)&G<#tPouUXJBz-cukpZ%TawAk#oZ{RP+=tb|;4Y1Q|Gi26 zG{Zb*PrDl9-_yd+fK|hOj(JF+dxQ^tNMbh!^FCH6f1(ob;o|)M{GKEj30=*-qAMs) zm#SIT)s$xWTV0_I^8a->c=YfaeS$RgXA{OZ;C}FILX`o(cl(8JKKO`dSx<>1yC=CP zEtFJpW!uhhSrO8zvw^>-%K7t-7^3Y)!|lJbkEiaBIG>46wpi(LmNympHM%$-@6Cmr z&@ZZ2l?&fBoH#CSliJI!CA83jE|fdvV3|c^n&VxmPD$A~0N7ESeFVmgDRQHEd&-1m zf{U%c!R_~XrK8xMXft|N%(n`BNl#)dOF*renn9aon`I2VOL~*M0IW=FyeE|)M6F$k zi*c#TM2Sw!Q|Uo{7tV(6KERIi=0=%i zIsJ4O65%)6Z?twKs`{iAttuSZK&sAo`;zYrigmLNNq!4+SG*cgiBCx(x@z!C)0uY~ zK}Fi{F0lf@7b|g;-5}O}^5Pv@57|r?&@X%8!>6g+yyMm9&zm}3jls?nCn09c9A1zw zt6-$&j$>OHy%+t@el73)&$zkcU*Yl^r*tgQHv7OFc9ZGbbsl?7^&jz`0b(P$tg(Ik zNSS0{t_X7Rr5L{a*XvFLFEU{BG&F3PU~(CZ#x($;Zvq@|F5SAV%G zE(yf(@Hx6}*)U-DQD_vd7~8t8J2#XRPDYv46g&LXA7I|Wn{SErONu_?h(bmA${?YR zHUPgHbS3h9>J2JA-+O;{0!3v!0gmt*I$3ef3Uw^VdBv?C1&-E<>SSwqc z0&%7INDW-%s&hg4?nr5x_`I?8t9iCVXKZI2*wSY1Xp~59eFBcjunbEe=f$-v@9EXP z7;!iMtVXZlXH@hWbM@tie6sSX%`~OJK@zUPEe(OQ+@BsR&<#vEWSur1%ASglrKb~u zoQ){PQ71%gW;$t#n}KufJ&9O!fnrL~qiMY;_8HSQEwI{O#Jz|W4mH(CBTXOPtIErp zVH2uQLZ-<6>nd{^zl7mU^&oqJ)4=vN^gzGedHrW!Y&>iO{Q>$7f>J>)BZ&t!9!e(Q zFT~$7+111*WV-KV6OE$g11ZU@%*L6;8aIOHK5NhX((+cy(9SWu{Ta|su`3k!5Z(A= z4mwGyK1V7fcztIj=DsfvjyP&DqVMI=MSkpkv+pXp_6FeE*di%`qeb+hIa21K$Sd*z zSf>Es7&o}Jx&_eTSO0GJzPcfQo$oPSvDLp0$*UHVXdKXXlgG@YvMp)%S70vsjbLEZ zsrqFmVdF*9}GTrYja8^5*ut)Z)5#SQHHMG)C(diOLNs!;Wi>YsLDH@TNLf;flOE-;O8xB7ek(ZKGgTWz2V3k zf36I;87Qz8q@V}YhX5$t`9H<>qwj?Q$Pt(U<6#+8ymC%J=gIxnTBH{`T~r}Ue%D9o zcJ|k?8@|r#+?S>wbfky;-7X(8(VqD0p^Mm_TLzTjDyR;>>u?o(YLY}-N$EPaASCTciPNnQ4@Ip z@5Hanst=SaDGtV67XQBGDo4u-{CT^3T0W*0o()iiSJOuL5rhd(6=G}oB4zLw-!hM) zbAZ+9262NI;4#zm)@!*Tc=pSyLW66Y!Ia!Bu!Q1xpdeu0LwBwQ{RYqf$Jc}c+lK>H z2Kp6XcZFWMPj%}T$vd}-eIwH-9p7O%a7+X!odwJ6R7IVsG6 zf!a~O3LrL;?1>7;-xO4zbpa~6h}{Xm7SsmT$-Zy_a7EEWJ|PLf2!cFwQ%aei?(L5lI zU4+`9vO#;X6SO32o41CrgmW6<`k}bf5$mIR6n$S71`#n4@rkMaS&_h{4;CgLwW~r4 z9^IPG<=#jVDEF_V%&prW!_`n1LLA|0fzdk-WZ`ayZin2#xGDituPdtw#lwOqOl>8O z>AECU=-MhROmItq4{~6yjlEb^;rU%@KMsSaCW0G z)O4R^+3wsQzqe|M!1Y2S^;3x{{&^X##PlYczI>)^xI5fegxAE+<5(hNKb;duL`ptb z@1WyOEBM-Kj`hNVaA}Zxc$zoU(XSLd3N-ucwzy#Zii9{P2-uw1o!Iq4=*){VN}ce_ zqMF!-_|VC5$Z@*TORy_0=+X0tX`KI(bj}QyXvf z`s+ZQLS4pjpXCKlklz0B+f9K`iU_*}oCt9dnrc{}c?N)J7rJs_3ZOioomtOs&ug-8 z3TU*P{sWG7e-gbG1CV9I-}s}^rhfxQlVJQZ%2XzzW%F;eR-iD-oEVcf!8!R=U zromaCYDh2ALZ^o#vOFb-m0+G=o)Qq^-!Lsn+oSo1Fb7^*j9>~K261RzB-BJ&4gNC6 zT}jZ4c0;;8bK5DbHM0aNf)=-+0xo~Hl3}e>#ImsF+gYWbotMaA_IFUIF>UKL=@+^$ zvO=hmQn|U6-Bu2T)g8_203suyAFq_Ie3XNfsWS_*wK0ciOB4Y0jm5*oLrc{DI+A7I z6X=GUo4f+%R_MH}WM91|yg>ZUsBFvg@w1wb1(|l)bs+73qau%b0K^fTJtSxRVCYR@ z9*9Xaurml*9>_W_>ie0y-x- z?j{$c$R@Y|b9HfQ4wI@&j9?nHYqlLcMntS-_(Z@=u6ex7XHcZp4Ajy@C|5%?v-$hE z2G0L=7QJVmAfkg)pGujbX1=BX*c=dcgy@C*4IsFIaLX>d84_v~O!&V5Yv9*kmTaij zT`PfCi17oMnmKfHsB4%#!mOZ`&_o3uw4Kk5GJRT@3fI;w@M+Mab{!ghQ$z_Bm}*z= zm!?wplJ`fyJ7?rqKf>;b0fbrPMwJ)4WMLD=7Yj`UYznJMjv=?ZJMidv^ zZ+)L51G-*G?;>A$Dr?#eImy{XJ|*`zLWqYC=$}G&Xp}4%^uBqu2ezoL4Z(N#-d(dh z2;Kie$=K%?w1zVH)Ny6B^V6Y-Q$?%B3sn8dTBFaB(?56Vqj$Dr zVvj-Bs0Y!$o(i328bSN*`|TDVlbq<*tcn>o`^@#Y-ye`5p{680$DLf-=9?IC#FqW!)X z*kwrXJHfxWq_=wL6!$6wc!{7#kB`vwOFL<-$DCfpw|{2^&c81Sa`AGB>?(kA4O>k+6&s)fgY zFi9$wyxh1NB8m4QgMcazEaP`d2|6PAVVt*1Q8@4V_#8f~AxtRzP$g@?{b3YiOHFF& z^*Yk?QE3|XwmM`WsWyg^$@+x7Jm9Y>=te@22*I@a10l{f>LvV@9;k&7U3! z)wSjtoSO()%uvJ={4I*$sNcPY%w_VlJ*$hs`prde z5BQ(CFvH8gPT2kye(ZIq^K5(T(&3>QFOJeKM|b0tXbS-Q_ycI0d>7uy`q;Ve!7Kdo ze0?>wu_;bK-g*xTu6x=1l;h6tF&u#MFJ*wU)6AD7MAGGJ_oF~eLA7Cz}jfG|6JmrlRu0S1b9c~RX<5Noh{G;-ykFW!~ z0~?EEl$Ju{?Ds(?m5OD)yz(nJEtF=M@2@P~BvT=^GSlBQW9pHHl)7zbpS`o(%qVSM z3^dc?V;gjNE%fDny-zwDzijKmioTwVvn~c)g^4g~58ZY%Xbf?HJMq?r&uoKJ`##<| zA>4T1c-!LBAue30}|jbHCmLrP+>hk1zko>Je)KQT9ZD&?3z&*b1Qh>j-54 z$vE&Lbo8_W=DLul$&YU|!%WDUgRv{nJ_rC$_lW`EzkUt)G595`PRLyFIrZ9nGD`;3 zMEy-}8UIr|&&6t=2gOV0_0!~8K)4>GbHzN~ha$7jqZufjJYIH>tNFSPrf6&kgs{uk z5+TZmY^41_LCgg{%W?0+(d?AAm{jTebkYLL`=PA0d(_ z*}cFyU!QHn5`GgpOcX3Yv>wY=f@IF9aJd)|nl9Cx^+G!Ev6~#eM$%?O8k8w%&Q3Ct z4lt*P!y5|MtpRszsDtzf^awhTBeNp2Mn1S?Szxds4nEl+nNHWD9eRo0Cco@(82)6F z9;Ed(Wx`?o%I=1tqoQ{TCA9f|0$82(w58|OvSH*og}JDAP1CH-&*!MY$anOkQ=Y)1 zD^Me=WupGXWNkvtG%%>3g?jK6^_x5v2n@!A=_QmBm<>4opb=16)IT40;g#$11!Y?F~ua;7Oi)xcltp^=ora200$~n3aTgep;6*4u#sKhr2A;_qjMi7fhvhAsZZP$BEa+n z?fN@)<7Qkl6^ruNF}=AF-;RiVCiYlV?w_^#IVV*X}uz*iOKHE>i0pNxF#yQ67(fusEtAZ&AQL%TbfVf=)5I# z;o5cj$3ENv+yN8OOfo0;=`XOhkBtXQw@{pEGZq@}S^GMO?#y%z=pdKQKm8Y_Z1Zk^ zTXkPIaqG%rXc%W>Xbi8&AHBxX-#$GNqkjKlA=*F>_c*Dk-(L&DUx=&{(yHk3zhK)u0P}Dy7O_-Q_)6L{C1F?}`DT3@CV1W++Y+0V!=W0Ew@QOYC z8U#9eHt>6lnN>eJv31M6YHs@%W7cT86ue20yx%>4yyt?1?`0qzsyLOjP6rRB-I`o^ zoCBpt3s)apaicettA8_po{t~(!~Z)p0=HG|Fn^D}{ew?W2vggqqKg}&J-#EpqYmsQ zei@ul25JTj1`_+s-q%S{H`lBW_>=I9ED74))mMD|f@tj$7$}Jxv1x9^p8O4_BV1q7 z4kK0$&jrK=|y3efdg`|Rnq+VhB8c8;PZkee)FQa1AW2X zIM3wAFXpZZGi`TKKC@iRf)o_U9d{W1p)e>&pt5PsyREZVMioQ%&CxH<(NC`@Zyk4MZd!J{kumaSvkkLu-s5%- z&7>@UL_hgZy~JKWu0Ql&MLdx<$FB^XV&)W^DUarEFubmKzBAeabga8}U-;$`yOz0^ zxf_JEpIvtT<S}vE zc*#L^kEO$wq&z3ex=2kDOHWAYB+z84)Y8Se#NTEf)PdUNx=M3HXE>{9Z@OIVlG)}0 zIbR;cD`t5TdkQ~zU%tRK>grT76Zqo<04Vm-Gwi;1LYsR)yznIiOr{oa$eH^e)k46K z?Wk1)gKKm#H)$ZATnB+o`5xShr3-hEz+9%k&H09A^ zgaK9v@RUiKe847IzhJnB$Z13i>ux7fY8{8U`B*Sy!czOk5AwFY63#fM=ATwE^)RdG z^TK`Ig?Y|p_b@CYW?(QfIu0?7NW;pEv*r>yFh#z5JPTUV`DWMB0l)3uqF;&lq0(?B7XJ-|WP@RYu~H^*8tL(0H~9>a?pkxF!^!02@HfK|PBUTxW%<<(Nc3vs6U8ve zPSh*R=I+2~)Ej*6qC`X3YEf_0@ZsD9DAFa;MS}UI#Yw4f)2P_YnMJH%72nr_GA*=} z7^(!LedMnZOz59J<7=rPQD*f>Gc#DX?V(?g#lZvw?po#N;#2FxT;HTtaGhx*QxP7^ z1-NbK+aS2j5$1ibou}4^QK1R)wEb$NXfeM7Qew>q$nock73Yon*orbR# zuY@q=C>rqA`K?ta4@%$kTAX&w#2@7jSPLE~OqGXo6TTXDS#})^!Y&mxDxTzl8^vux z=Cde@R6ZAExSp3^lwXVluh;dM2N?G(8=tb@L7$ytY{cYw+8;Xs;33)kMTspP_cTU_ z-PgrboiZmZ?McSPT;P zdJU=Khnmg2v1{mi+4Oc04tH=MHX&J%YJ~n+U^MB9Js%8Pyvl>ip%!itR{2G(;J*1Y;BL|=3p5WlEA!BoG#*SQdK&(EHpewaN# zq?Q4ur`^LU5OLj~Mc|{Kfp+@~zzn+QJ$E?QL7Ksw!IV5eJ=R+Xg>3W7MvPngl6Pgm z0$qZ+@t2^OBeehu?1U1|9bc@-7@hi|=YVd`!Xafk1O?dc0O|JN)=z)@EEv+lbGm^* zt01w}n{Dm(NGppKx{`JCZb_E#WF`5e20DpX&O!C>c<-j?`c2eCJqctt*>%#_@uAgA z7_74Ej~zaG8JB!s;zim)NFY(F*ydz$yVALhpv#}+F^EYvL2_SMgsF95;*`0&gqr@_m7Eso#!d|yzX2yR)sQ%vMP z&>Rc_RTJS7v2>5=3Dsf1KW7kh^{b^j$v3#yQF(MZ4cALD7KvW%`}5WTuF4!j=edTW z1uw&fy2URi^$Gh7&7IC(Cy&IW?MnXi)E z{wkp*ubZ*$0#7k6$|L<)hCXAj8Ma`mW10DQd!pechPBdX9;KJwL-JWyLaUKV_BJU^ zy0(Vn+1e%LkwWJ6rNgDeCxmj?S?Dk5kzoT8TO-pDq=_P~KvF zOZqLw13KhD7C2aW`FMA<+`oQybar%vCPkeWcfmbhv{1CLHr4$}M`0o>EDmM7$V7!{ zQz9c&T&9LbQb4rNligqh@z40rtarlV$J_HmHSrYQ8qekTU)BXS0MJ1SsOk9JL6OlM zLSy%Y-zqvA9%rovtukjmmT_&L{#{9KV>PPPZ*H)+-q1L&yaG)9Qn$;^$IntxxnIg^ z6t+DhfX0v@n2`K2@w9JxQc#OuJ_q2*X|{D(+DroJk^zcS#0Ts{bx50dPkHmdeOif0 z!^HEcymyq$ehfY&v3f@4lAa~~az!|8qgJOpDyp=~WS0~jl1~t)|49G|;~-|NjpAPa zyki{~6df)-x@zUmGAT-mCoRd!97a-dTXwH3Cqql8sv8SuR5s5roHL0otg7$HB;{uQ z0xe~i*EFc?GafqO`vS!*_^j^n)zoq*uOvSZZOYe@U(L#z*~v#q8oGdV60JTu;Y<4k zi&k&>*IDau`T^4z>1`|ryhy|-#2^AlUUO^(b=X|}4`-xMEi6VM__DB>zVH5cz`42` z!^`juW4=_8RI)y5KUcW*J&)LIe|f|g#`W1g9UMD!ct{$TC+2_kRQjm5sQ~tM)^mdU zsqAX2uQOuEtCp*lovb3S3_gkPda8-ImGhz42CV5FnX{>xB~eEOPIJet#j{*;d^Xyj z702B8lrR!t!}6`iupIkHWhcX5t{{5e!r$=T7(uEuh4S)5#To_LiB{@hGt-gbltd-1 zrs{8B^?0+qgA2D(G|c2oks1zM&Y4c%74@V;~d@$KRs zNCQg0?eRGJ(AWb$F{r!#Cez<|0(*A7T-|lmy>_+y4rn{?M4CfgtPR*A-D^gO!@=dy z9z$4aYP7RmJ5+1_Jd7%%53Ps^(cE!&ySn5-@$~67_V|5F7UU1+uULrx?LYE<<^zZx zK9!smbz-V}7hj4el4lRMG8~nb2PBZu3#z#LTDJl|-p@V(0=^6|87GB(YOsl3B5M*P z`L#5nA@FK2jwzO(`A7tdkzn3XTTFt{=Gv7rL9t+;FCVe`*A1!k%+x#Irxt?|m=8nSV90XWGjVet z^{l@Q zBF;0%r3>m5Cu)l&^{Pspat|y!Z6c48*98Z16wY6df6oWS?oACh0CUEKAJ;6^Nm_E{ z)UkVf8KpX#>_oRerw%r#UnbtFoe;ZQ>s~uFcm>O_6N_<0>vyz(iMM*Zx$-+*=!7s?=_eemUSelIr-6^gCjsjO zJ*@u5JqG)%*Bwxud4MV>QES9MS^z>MbpSWKV>{pKaY@5&gl|6+zL$sq^RHc=7~!ET z6LoMfVT*xG#vsB^M_mM95Q}T7w7JKd(03t}kZ*;wKERxoLnC@6It}7-B{Wr8!-5}4 zob;Wga*AaqhWErP4T~m3z044xeX<@;OalWMnU`z~Cx_5_Y>1pV#|qiRGbW~x*lU7n zL35AKk;+|&B_CN@GL6!{D2f|B_1%Ukip8HOH1aHIa_g6^w^pXNC*VL z*^hk(P1rWSrEVf&R#)0o(Vg zis2|=E6?fseKk5pAk+so$Ghk;lh{NI-2>fYbVbQZzr<~5tLL<~jr319sR;%O^Xz03 zb2p3gkby`ir9mwJOkXUor23x-hEGSnHq<&37>SRL#1cfx!9!^!d{{u9Mj=cP?j`&A zyEQDBj}u|6O7uo8ve!RZKd(ZG%4j($##@mal&-G<7nNm%l9e(@AnEyJG*0Y`|Y-|bGI#zTH#3X)6F9PABeG5S;r=>BqdJKQO;_c%RiY1$KW=-mwNM;E;h zGPtKF;^kG%EE!Xy<^v(#h=9}MuG--&W>>8*#UFB>W8U~-4L=7WZ`Efc)qyhjGx;;u zM1I`tA5N%)PplSa>RpQkb8kaG@@FsnHbYH+K^X0{y|t}#RyqifC09#>o?y<^kzn;z zQlX>&K@4LKfCcli@v>c0P&=$MnX#|*{4!IlGcUbT_pG{GlY9{hfI(rj#@Px212i2MCOd>U+Kx+&lVdhHo2C2mfE84P? zf7Ni`7gL}RdMRf9-9DV#Q48uQE`Rfijl-@b3RL9<9%^|52>NUtba4G9rY#sQMS-_` zhPfZwl8cnlR$1#!`r$ukP3_Gi4b8<@(Xs~Q8^n3jtK)4R4a`L?VazHV72e=VcoE#_ zO&6s(B%u6vER4TiwOzG+SIUOuzu(6!h-_u)2wQfSdtxuGiuV zM72u|fd3Q!oy+MNxE=z^{|cg8brygxHj%Th#MwvP4-maP-Ch}L!>c}wS-05(6ftA` zigd+E%0K>W2!liSRqGWI;q+bi;n?F7%Gnj0Dk~`l=$lEelXA2EzW|dhb_i-_9GLJu zf^pVgn0zu2_IZ<0vOEl;w++YE3v=1L6##Ux|9YGn;Qz#flCc3WGa70-%C_*FLeuw3 zTjELuZi&01}!$E|V)&IGrb z{}|u@Zn$Q(W<_42iul)`aXfL)s+^gBHMslE?+kX0(N4rVv04KIIwR=x#IEvg?B>|gE-KScDeSID=p|IWpalYp7ozjNNi->bv=Jwq%qr7L- zp?R(7=eYQ7>TJQ20!@y-Xluo#5=a2ma?s`FalvhwF1(FtnL~0Ze@gk?iO9ORP(I!; zY$=WFk^7N5{=wPRdtP@yq4>=2(jfJZU(0{4Ak$Bo}dcRz+5YU^noKh$KuKmfOX-5 zV1qU5MiWV`G;K{fK&eqTE*sF8K|32Lt|sIOz3cN33u&ni3zgR3%~UNqNV>*)6Bidd zh0=1F?V3YL{}M>7=m4JneY9y#qeyv8LhoBIu-M7`)iarBeT_LTS{Xq;pS< zipjLg=3rpAd6OeB(udB6SHwgD!b9G z@B&@wjySTPBoaA;2}VwKovq;)|QFz3x5PxQq0vm~eEjz5-NVD^s-m~7 z-u|*G#}8P8S8?saJKc>^VFiZsDA5zsK9cY7-6hA_Y|M^tb5e)*h4Dtv>aTH^| z&#JFs@5HXeu0~!#t^((-7lP|cdrN!P2%Q6fHj00Mb8sL_2uu2xM*&aJe}T*eRC?;4 zlc#omBz`w}ML{zH1%L~!tDG&GU$gSskX3i$~ZHwJ7Bw zsAZWqrrK&x3LOHJ&-?L?mF&M;F4Qhg?83CxC3J~4ge*vha$))vU^e*vhMn!8ma2FP>Tde%-AcnneH{P|B) zF9+VCsbn02W*@1|+Iv(X3|H&`m_RCMI6J&+vWr_X(iN4b&vU%P^IH=1Smw=J`|rr` zbD>YviE6lxLPU@%mAuIUewEGC_fioPMx5t@Yrr_`zsR5JUyT3+#crH)IPg&oB;-FJ zGM4B)hm_cANxQ0B5jcfl1a((A?wbvIQ?O1ig|q$f`h1Vl)6?SG+$)(jlTA%^zgY3V zQn50W3Xx|zZ(L!q9uD|%TmjhGI|%USP@K&`v;5QiK%i3N^KW0#uw+fwmon_db10>` zklNOA7VCY#r86)?C<-N>O%x!JLWx$1_8;0Z0YEwC#q;*6Nm0D#)&C{PL-}qb8RRIq z>n@MR>kJt4J4!oBW6YQT^DYxeT#uDB1o|^cTIgub-0V*Qk%9Y>`;o;9AU&>Dt7#j1 z$PMEvjCC=Wnh?_W7*Z;a!@I6n1Z^Ry0&Jd{$YmR~`zaaI97=6}3wrHZQlOCvia)e6 zm+|89wG3`M=KW9LyyQ15om@hZC@I087BmSgYICTIz6iWS#c*FgwEUpXCTIU=eedxm zaQblJCFeO7`OvsXWvq4nzkrGm5sg@N6C$;DSrM|r%YK)>o`|N%%0xTJ?O0q;ZKVpk z5+OKq=yp#dUkdaC9 zjhsfX3)XPu%bUJjky4_-r>}|xqt(c)>{7t|z1#U80A#dj44^m&$j6Km^7Z6c8{z5U z9|9noh#;6ija2MvI5HltKM_Z|M7c!C6eHhFXhoL4D#hCZm7s2QP>0fwoQC^tDlW;_Rr_Acdw0Zu?=q#dx;x1=7z;EDm5#i9Gm&LP znk3jpI7T?w6b;H&dDCfW6HO?k-kLXUrAs-(w+u^VCL%$*cxjq8aF#byheZz*onJkB z@3{@fYxd@&{fmA9icpec5U*cq)ZC&M@DKN%kx){?RiA>A{Zuos@rOyu;*u885wKV{ zACOEx_$YDMR^@E=^u~1uxEtIcTr|68$Q@pAkx8a*WX<`m5HeHiLTzU7{`u}jwtF~d zDJ}yV+rK(cNZ4+SepDTUX;EX@p$s+NB#iR?<0`MK7HRZMT+OQCn;I$>lwAK0yIy87 zzOe3BAg#X^WfI|#EDF7&?^m=uJS{hkUp6Q|Wq-=v(o$SR_X%TjfIH;fQ$LXVzqmY| z{VeKfx6tP#pWd?t1!}rVqRqe7zgYTU`*Q&rx>r_LR_hFkKHVV9JyqW2B?V0M?1LwL zVM*6DPw1UK2@9wD9mt!P3eDNPVeW0d9X=w$Ml{wJRJ=Z`b`u(*u?PEJIqe;d%~3S- z00?Ty$Gmx;zJ?xR&Acx~%x_Y(%UUH{^j^KaYRn3-&H+&1K5L&__f*B)sLiT=QS<{! z0By?=(tCHS`LZo+Cl+%X>~~5S74_U0jEK+5cL4}ve<2Lt7GE1)tYgqkU>Beui-Qj^ zSaqv;q&sxfg|pP`8gEmlb^J$fBah=^dcVgN2%F!HT1e%I1+30>yT4DMJ&XXg3%mN9 zd!L_P0{oAc7Mkkp#5ESmYrmLoIPac}ETyi$+XEopPC$Te+^3I}s{*D@e(p!lS3!hc=8dw2_Q*ssS(84=x|%L4hy^p8jXpzEj^j*pY8Ab zmWNvs9na<>%V~S=XYYXtoKYUYvHK!)3u{kxU28|nG+NBf2S1=;ZIOI2mr!#+Zk>0N z*XRw(NGSS2U>8oJi}dCDw86S-|3&!Lhk0&*x9TLnBOeMIahZ@}4cSf*|K~NFfa?x> z4UXV5=FybB61>$3B8AXhFv`pj=Szl!jzYmIo)g7eHHKst&IyPCOS8# za8ti5P3X7RJZp1bb3!lWu3BtA{M5X<;U01{vtISh$B7>&ki#y^?Ma@oxq9PwFse1U z&dO|N1YzBK_NCl|Fi@95lP>U(r!fH1-mbEE?L$SKqpCqr7BTbxPiue^j?C_fc>tk= zq_VPF<*x3gF!`chjgXY+2jP%HdC=e}YIdJaONsR-l$FAWjlLg8D~R zD}>_9&Sa6}G{8UO| zOhy_21zr`U5LZ4-UjBvW8Q@F$eGu9>vt~>yB>e9xd~SmU^XZIAv;I2k5vxu+nSh?4 zo*+*5UFaFsn+;M2p*wp*4zcNhB)dCtwtReBHcF7dG;|HdcJig1w_3c}W43R>Krw97 zM-=2}X)e!1(RzXtNyG%&5nLdrgzp>*Q|VnGZX6>WR9>SM?>zK#zriN#bp8o(X-o(7 zkD@jv35D4$rBwsyevz#>guYJ1*;aA+ahW)Y(nq&QHGR=d zFGInjohgtf#l6_M8&VQVQtroQ|4KtO@#2Y6sWRfJ?zYvoRS%eFNTW3>U9+w|-y2f% z9{@oBFB3*Yo*{`505eAjK$~6d^7ZWZFMG$oqs%-!y*pgVbGrI@C1W?>uPVRu17$#5 zOjcUcY@oLOZ#5(%4!gXLq`<1W7Q!%&rPVeivWH37pZ=}Qi>{NV^KjZ$B`F1={?+|HBnh3KtQ6NQrYB+wwZ}K^2HFFn zTgf8Hq%iXk3I9gz41AXznXdrm1J)>kQo#WKwH=oSy%=FZANSWE&2BflGwGTeDqC_< ztX#n(*MQpp?hLKOEMx$++)b;<1DXJu(D3N+Xm_$<$;1c-VK`#%#q%jC^qkwB#boPb z|Lgqg{Q4`uq+jP4|tVD?57L%Sn0K{B)NGLxl9jhpyFhHLya6()Ndget!Z4 zf6O9&2B#GA@jFP?NDEEiZ{4Q#OUsIs+jm!A!QHlw zmUSlc{Puc({f5h4|bEkiG&{c=@j= z9K{_3Dx#eDQIf_nMZnE5ioYgALeno#A#C^9OQm6PdQ8#lqTsuL_`bSS+h2=>vxNFb2h>(lB@`mmz!R?tFvA@ zWLFBpmq>3)NiMWaSV3rVWFSX@607fvgGRYBwwS&+dnIYNDNB67ha=}alrgyJKDT5u z5bM7u^FkxF*s4248k7`fSfflW+B&}iCcFs0pFeODXZrM}5slN>NB6Tkb`TD(wwRq> ziT2cB-}C$9)%({H0}<9T#e~4>D?0{uFfE#53g&_8R8b)-lrkMkRC2b3`b6n(DUdu0 z4gAx7*d3q!iQ|c*44X%qU`5TkgU2!u!ZA#=^Fzjd+IiYJ0l_1-W3UF3up8MGxR%=mt;m-ly+C*l4Cwhd6oE7vJ0^VKec^D{B6a^W*$_o3xYy}Q^% zZ0>tWX|O9hK)EQ;+3$PiUniD1qQmG4;l@|3=I5E6Di$Ajc*r}?o(l0MjFpdYel!s4 zdfNcFN(YGb(p><8gY@RlzIV_%{>(i|Ac{~v$SY%a2`YWF*e@pdemCU+CZLw+T2o$~ zJqqcH#t#lVl+ESM4fCbVU3B#e@alc54tPy=)l^kw2+yb{$j~*7T~#H*i8Cs}!DdFt z5lIyLWAPttj-ptW?;Zb{%j(&>M!yc8oqAw;lpS~H0^#>jU5>eF>3-bPiBai zN7+Nhk}8qWL@v!)UF1=Ip0nk4j_G~vJnN`R&=gbQ7kLh(ZxFsBD*!#D1`GfKaBAcH zblU~3r9G+hq4=2f>F=w=Z`oHOqw}uTR|=v8*1yR+a>cD|} zgztd`kawq_D%^Eejkk~@d6Pd2og>bBIcItC_o+pe5aM8tQ3DD@?A)*3!;zy1;oko* zTAe@C0*hH&^!j{%gS`ZF=ed04z#8EA)A8p~Qc`Y{c+ddal#dVBzYw9zcBA?lEJ!0v zJIt|p*Wd*H`()*S$}_*&`dw&dcBTl~xuf!wRyZZuSXw-eFYO4=!&Sfz@K0CiNO&ui zctm9{c^x$aoFLi$QPG*N-_&G(NOR5OtR40EyyrT{#w_unwe!DM^JLJ038Na;ldYxq zo>A%7RY2oKs%^1hAt)P{>@Y?^hCmJx6wA<>uv9Q=ewq%G)? zhy_4&YmNahV8kIrb_YpQVQ>FJB(R~3i4 zT|xss?TT+9XhQ!t9e9+cpgs(5&1DJ2grvi$5%=*M4y3S~MM_;Ji_3onP~>|jJSrbb zD{V7g;yrYC%mD~Iw;;M@>n6)NWmVosMhr-9F+f^IpswJr;Okgj!v!RP3?!w>Y~3CN z`?();KQsfnVf_$cOuOA7NFyHxJdGJp3_bK@B%3Qn6Zx}85W6%8$WrOL^T~#Bn;FCT zW)P@{tU?(6k^I*MX68?a-#>yt%G=j*xS2~@y75_zz4@CzAwzJu&2&&~HWb<~C^zv{ zkPfafdV12QRV6gm2ZTWjqEW`!y-cH!ee(UFfM)78hSnS)u+a zI*u(85p=6_j1<%n_?)(GE7OKJ#GZzU2KG_{wG|B~orXq3esg|v52WwpgI?e{bj`d< zDLqS!pcRxhyxWr7`%XXWMj8kcY;o|zX;0}LzRUr=_A0MufRjzA=G<^@ zS=#xQ3|%#9ef3cUe^|^i7i!IuZj5n^Q3(CkSJ1Ex1&>72MwcD&)O-CDQF|=FV{euJ zZk1SxukpK0!I`K$eteXPmtR*A6>kQVj!0bLy+V&D z?9yE6uw?{K*{c{$T6!A+u%YjJFE)RYKn!zomkOnzk06-A4wfdU)0biEb~xS4&gdxp zE6@HS$^oQ8*1m5pA0&97Bp;bHv#jGB&hYXR;z{xy#Brn4grz3;`!ZE-ISYS9002uE zM0DbN!A^cI%#?3~+R;w1R<7jxU$h0Oido@^JQ1R$V!mK(Cmh47&c!No?OIw3ANV`UMSKG-{_5 zD@DY2yLi%?`MN5!4^SF%=JkuI7dwi2`3QjbhTJYa8nPZ_v(9v;I};;jI>7GxFUdJ~ zjtV!g@qw2gV!I6yNM=O)LJ8f7BhMnwB$%DZ!nnJuo*9-66&h(GD#7^SK~g;M@_$#s zKqQvDRDYJi9Cr4Vp&C~yakPloN#NoIxj&G2l_7+>{jufqH>F56YbaM*4_Xf%Ys}s5|adq0xY=exIqlf zZ;3Gcy5@l-ujjs$Och93TV-1P46-WUdUt0xKxhw9&r;s7s}gp(Jh5@OJKMtXZ}P7= z+MUanJ4vhot~%|^tHI(?7+fExk;a6-zs6og@5c}#|AdFY3Y$$-)%>i-2j8zzqi!QQ zGg6wW&Oy;(=e~B`xjugYK-PdQ^P7Pxhy1#!O_ERG0Vi*TeuPX25k0XUc_v_-TX{6# z(rQZe0{C91wIRhJK!vmj1?rH()qV2QAT?M1D|J(3SK`T>n~d!&>3v z=kalE>fzT|%%o6(m#hcfcYMBxjP;Tu0BTPTgdwXjAP=E#^ScDL!KHwenHKUD1KQy0 znXFOonE~OT(`Fy^u_>#E(w^;?X*ZlA1L@XN;oL;TZ^fjp!5+aL2>xA>fCTO=Mffdr z09*3_KtE)^bHXbx3u@15&&nJj@G4X+3r`r2Ejusd16vO!`j~h=<~vm@ZC` zFzqXnazGw}^o(@oR=TL!5R-L{nYS?JZwgXM^2FIwsM9T>Sg72_VrGo&)0+jL<|2aP z@yto=hI&QBn^HIjw>q&RpCPz?|EH0XSHL9_X|z#fv?{DUJGS~-d$`fRqFfc{=)=1^ z?$WWN!U{Yg#D`o@WnDO6kM?Wup?G=Ou%k+)>RHn=Qf(CQQaDDk_LFy2XQnG(ZgDKo zBBRWFF zr~o7GKJI8+GJdksZ{@8uhpwSl{STWAA`8E3gG>)a3RDw6t81g}F=kbHt|IRlkNwHu z0UJ9G>_(D<&1J_DGD<+C1OP2|Sq zZ4f=~(*WFX4g3lwZDfKc-DAfZOsx`)(!^4~32Km+;}$_9Jy`v3(XyNo5= zfjP;-@kO3;_Wgzj*rwug4b5Z)y85)-r|L$L!Pr`RintHUL4q{Q!d09-Cq*gpWA*m$ z&_FgPox{dyTcvZ=9z}RzQM09y##Gy$OKttXWg~f`qK0Q?fI`mkMr&=W8zwjxL>EM# z;NKyrJU6658CC!vU{&(-c|?Kk&b#IA?~Z8Zgp<@9M$Zg~=D4mK z`t!r9rw@XOQ2K+7nGX^f8X4N@Ec`tVmZP_#69Bzg_eaZqEn<16hCvx-A6g_4AqR+* z3j%yP+RU@H3Rl)Nvvi0aY?%^F^p!4=bbceDvuOvYG)$;>M8!JTI0AaZeHc?}2Pq@4 zX~^Mml|-ltxphAUqn6p**b=T!`Tz?)za!ZOWd&M(V}qC*7}(YIsPMxiMO<2^UhJym zV4E-h>jEljYzX>y4ftVy2I0FD)P!nB@cRaO4pH|EbM8)e&Cv^UJ8_&bOB4F}1fs|D z4?xcC(-5Jd@Y4b`ch{(08?wXHW?{cwFhiEcL;ax$HJ;5P(P37lPwOiFCty+$FXi7= z*Hw3h1ow#WNZew0WPW6BSEcZ1=kKZ}z`#=W!kAq459$ILNJ+?TFvG_XVMobL%&Fn|Zi5SVsp{$~kOv zMHHjCjfZa$9onXZGw=KOkX!HlZc9nNMbF(}$C^VO(<+V^)r9(sOeIu}emMb7B9(%T z3Vfab(j@cBrP~R5la9yPimw>(b(I=7iIvGf3%WhMBfW#aN87fdu@hmbtWndJ6?W~C zdChA5NzQ)61%Rko&$x(Jk&-Uvf0hCuY@S-SJmnlDOB7`Az{O=^*3z!V9ZBC+xT2Bx z1L0ed3?R^gEr*`)b`&lOlJswbi?x*-a)-rAItp%+7GZW; zlaKT(In>_D9t~#3MT3+8RG-Q+HTX~1Kar$!b64=>qbrc4z2Z?_%kQT)V?c%+tc7_= zhh9*x?tniHZijZ-n}mp)co*U9?`(K%cp^!0v#a$|p*YCY_bU-A9Te1*^=U{aH=yEzA}qGM*=jgAoW%9S;AXK~J0O1uBS-k*ncDOvgxJw6>H_`~(Lpi>QrAmB+#*T{+2*2*0+!>1o)qhL*}C(($Zk7x@f(T@ zZj)W%Nf&>XulIVR;&^3e}&^pp4L@y41>|=r?J=k0SIhg zb?dlt7ymEK3{TWK=A8+my~m1v6M;Yo1h}3ZpxhN5-`xTfHMU@46VR~8>lPPeqrN4L zIe!9{F-3sb<^*BvuPH%-WE_LwfY2XQ8BzphhtHS_dBBEsJRZWg`t62%GGq_&AjF=< zBeeu9Q;F2B4Z+q^q>$!&=B}M4O0=>_#ScP5_i*0?-H#@8qQ%Cn`Kor>3sn_E{2cuO zFjOsZx-u-E^x|5noRI$?Nq7B7*Z;=>99MUDTvJywIo%ysPYl!DHj`KP^e~$ou5QER z#B@z;7$&B>`+M%^dmsORA8^lkzhAHCQ?Ps{cs{vqGH1jTI;E>M9~mQfX!-)seiXe|rc2UIWqtL%5nBNLsv++o-EZb0lb^qLOGQ+$5a=?(Ixis5 zhUv`1odp$)g=mqy^I9iHk&nWcF*@+_YZ2a~Uuu=rGMOsJJc{0~Z^shOik187(|F7Q z43Psc0K{1%qqYT%guB$c)c%H?l%2Z&_NTOE??ER7eHP&gOj9ZvXht+fIdC+{9zNEG zUayxO2GW-4x}cCE@?nL0GT%c!hE0BdqKw?YE^12w6c*nAQZ$=91-yvy{M(!nIFy!T zTit@A5O%x^4=zCgqVu_i*S-)9H+-#nY+sA<8*lTNqEfJ*GM)heK|&Ga*e$8=z^20= zn!U=k>N`=@bkyi&BV``)A4x~jeUTSK$s3b*z`(dPvF#K%Wd7p#0YdPz3NjMw3=Ssh ziU~|-ei#`HP6e`=SY@{}CwU9<7_S|Ve_9g9L8egm4**QyHxB!gEx!qaSZ_7X4OMnO z&Af2LVU|w6hn`YH9#nU<)uchHd#Q6QRnY?B6Sz_Wn6_in$n}}_yg=t?7-u+VxP`74 z{-W}40J~zSgeq3JA^FfV<1gGew_(oN0IFjai&GXq^#Fi;@Xz~_8_mD|TYH~t-bQ^n zP+d%GmS3{=OzM|JFZ0&j`Z690SJ%lb71oRT8DsoOvZThQ~dBQvXe~MK*ZovN38O=YDh%9Am`owpF zh3w63#(yf^()p}ia1ivvnYxfeCK=9GBJSJo+uKKyX9X(k-@F*SV?QbdhAE`~NdI|~ z%<>&;vt#=Mbye1!)@HZEyDGw7UVx)>Q1wIQ==1|YYX&FffoT2hWk`L5Oj=>*>e5<# z(}_OSj!3(x<@sG03er>BpFrm8LOK|I=yjofgg}z0nIga3sVsB64N*9US+Aq>>z%*c zGZ8!nUDZ7t!GA=nsj=SS_=dKl1L+fUPW_M~q<(#|2(ja7D8?!!X~y*n7BZ_0JM=&3 zdv1GfBVpZop`~FsJ;wdU{X4MT@N$Ck*WZJx@62*f-~%?G`?kCJKV6R~^GdI1e5<4> zjS?#cTw~}c#rY0va~&j6ABg}d9?q*(pY)%|v)clFav$_fy!APl*8CX3BYi742X#9LLi- z;^TzzxR;@Nib)|hj2}q%=93fHj4FgLyoyC?7RVkN9o*27V5KKX3iTWnwWEz!d6t+l zpk~c7tmg`fxI}=tHvj~H(c7bp6`a%gt(pl7f_KhmbN{L$mm&bDEt0pF+l$uu;0kcX zD*5%wRoBrIrd(1qJ;6n2KJPZpGSV5-8Iv~(rD+29z%v!c57S(>sQOeUwhkFwa0)%% z5_4>QI%8j(jOWP`jPK;Uctn>y+Fx6s7CZoUEFat+-01Z9Cr>3;1*AxXppmN(eU>09 z->FOx5CV`}r&id{308}rE^H{wJws8mnnB4R|AlNjz@wA!RSR4aSJqcP#BBj{U|WbS zQ#&09f}A{Mqm06*{CrP9`e>rnjW8O^$p<#d7j7 z(Fx3j#x=Mz%o#Qeqx*JkC~~RoM36(NAKD_P9%T_diAbRo>6RRm9D5+&c=&YXy{w%4 zP3mn>E=C*&xdE4#!#_3RUxtf-@TzJ6&r7CCqB%@Hv#1dd+3#ss+N=^-{4WsFzmV7+ zj4ym{q6wT20u-#;^bCci!F{H^)t=c0Ru5repEKblJh_^I#GTq%q+PBVYQCGKHklFq_ z+54~8QrunKy*)Y=d&N-NXo=uFALH}I)=gUH*K!i%`bR0YM~iIACz9@4Z3!ZE>YZNN zf3FjSF! z?{>Zpx?Vvu>)nb3VF*7+4HQy3E1JlO;`f>H8wD03`4we+ST%@}2?wxw5cm@KPQb#@ z(eSY8!)2VnLdkgJwD#|R;#DWTV)(W^tMQL!b$fk#-2ufbftD#Rd{Vw3dh`P!Ee$P= zDAt^vbHfFhC;=cq{{HM_f-M*g>oc(!3wJcUS0}nC%0YF(#@Bqr?zYY+{MtN_x1?}7 zbc=mR!kr`kvrRfyFoXV+fRaEWgW@ccbCYc^nf~<%u%D9y87QF=`Zp_Cu z7gjk`5td^a<#pZO&u;Z(Z)^Cl>P~-6&od2nyJ=nJH~?ree^TI-wGscV^(e{AB5~b< z7+!ok_w@a?ltTXHh;+hhT##YI$63n`HvoRr{4uq;$EX(|?h6Xbh30O~j8UnkS!k9P z|7R<)P=f&u>kQ<>HJ-y~a%D3+L_lIe&WqJ91f(0@jjrS?l#Thpnv^cwrEtK{{1$D` zyfsGfZTw^5=R*JIy6?h{`8Xc$*(`+{995bB38^Iae%$pZ^@X|^l04TST<`bGPO?fq zS5PJ7gb(rJg;My*YM`97`Mn}#UyW0PC_H^~>$5|41~wb@dx8v+?W{<#J<6jw2<6~m z1p-dG(l5!FpEFcSS4mg>26uh1z)?r$XvaTAzJZy+SER9Mw?t)a>mk&kS&Vj+{KMbE zvn><94&)R!6}n-mRY+l}F>nMyF7zBuUDE7xmO=gE@o&kykVHNMv}F$;TCcXGP?yaC z)x*x+fygdo0CtF$uf+Al&BP6F_hu$OAK*{Dh^k6`mU(yO$qQNqN-rBovyW`P<%u;O(KlJ0?YWXXVx;~>#*r&&sE8h z=1NYoG-rt6BUg*TmEj*#U&e2yZ@%ukc?4V>%ziZr56A(~T;Cx+@^DW8KczH{G)))m z7&8eHHF+_4u}Xv~it>IHKW5_n#QU%E#fKSfM&`xo!Ea~7Z#Q={E2Qz%Zq#qoH(}>$ zHD*ZvaJ{3*iX{KJ?LJ(AfGl8%7%Ob@}(E7NfJ6fOQZr542Lf%V|8-?gZ2rNxf<>j56|rMo*|RYDhMrsLo&Kj zE2Q&8^@t17im>_4)FDy^fx}N?8*?L7nMPFgCAOL)PFOcbn_ZdG$oCxp5Sb-oKml|5 zqU>_&*9~sIw;#pFK3j%NJmx+~#z>Qea6IZWZ-9Lekm^h9G{-(-AEqH#n)3s}Y2B^; z0G9fYs>M0iJ>e9ekrA_h&xb2JC1Xwt+aXEMn?gwBo->Cx^qe%VJ4WNA76R7t=Qx|p z%Y<;sO$@5a=~ebJ=Xk5KFWXX+>2v5!OL)KhEB;s9FSm5$+4X}C;|D8Xk(y9YkT4jl zAG+{m;*Xo`%T!s!H?qUdiFtC_ev>sB+2^DOV~L(x^uAc2khC>1iVU+8G` z>cFE4%2JQ9X=2a|L$}MmkQNHZP!~pRBM$@&1guddmu@<))4v*gqo1naiCHN*NB>;# zY@eA!tAjl5#^Y80B8@zwlkyDy{M&_a4+tfG@9T7(k_RvLU%`zJ4$f%J^nixdtgWoA zK&<_Y{S4apbMUGVA5d;9&l`S>T@!@uWGSFdAZJo22QJz6e%BOCPg6*#=lO)OM}(IZ z`@-sd7DzmTLeg_eqh-(v8Wj0BR5)`^_ssoe>}%`x$?|zqZLO0mPDzXz=Uoi z{qe!!vWRHNKVKI>Z1Z7=E6o^v=>efTa0Gy}&wT)3MAU+%Pg&ypLTN@Cob_rltHLlI zQkaG}8jI8bKc7PIJ2G*{!~+a+yxYqxnv~ATjeSgWyPLA&>{-pt!qR8Kq^tT7D3`s{ z`fO^9gbKzypA;|bLtt58RwyDn>!g9+M`&8cR*ZwomJJ%oaheaz@Q2=O1+#G!qHDm# zw6&Ctea?+gQD5L}(469BzgK(9TcP>)XbQpBFM*q9M*vox`#>kv z9qWHh>~pMZJCq+-hpD`xJ`tU$*-D*dYb)q@Da-lU1A7kNv6*^aPZS)u*ozanC$I_@ z#5&n1Qd4Fos1LBjj3)phbT`#9I1TVqC5Lit2wrv>0~DDJ=ZyC%eO0x~R}_%7++i2F zfcL^^Zm5U0hqj6|1+{XoBftM%)jTQjqY3ZbI~LR0i8`dvOiV1lCfa4VQ&}2pGfnLcuM|LAHyw9(r>ZCwdE7d3^h>l`xV?41F zH9EO)DiR7zUGtzDYtN-Q>%hjX;n$Z_3-N4NVRnSqBiDt!*+&-JyDw+s)?gB{vD*p`#eW1A$xpeP7YzjCq zukBx4b3L&{OtF2dr0E?J``03XS?YmZnma0l#>yY73R$ho#7Cnngvs1AeJ}|k{yjfO z>-=5_qjGc3%lSow9fAy>WEQ`vdMu3Q!`?PP1ZtxCT zBzGa5T8xLhc(R3L>F^a@O~-@1ZL8Z8okod6Ev^+MPz#H;A#vb; z@mai96Ed?C6~X4S5d+~g1a9|IGarqe?W$Z&bVV7$>;WQ;jjqyhZGWgT>_~V#P=*Df zpXr-l$sC9Yl=6XC_u#0_vyQX54jS-h2}Nzn2)r=dU-fg)ReiU z!PPGBpC24mGVA(4aj87zG+z!G;u5@pNib?dBb+AXAwPlrW&7dm{du(4EHiy>tvr~e zjs(v{j%g=i>%eKY&+ED$mUw?S>>N39lYI+|^W`a}Mo|iz{pG}k(;ZNAWp43yaC{UH zHtLi;`@BL{Rtvzy=bR-pN-g%jm5frG3gF25HHXlI27oh;hOp}OZHY&uk3LC~K7e*< z;#=NZX@W-(!m6kLC;Cz=(cb}K6}bqHOR3%d(}2{}Mu9prE{YMLM=N(rC-5L1?2yYIV+RW4Y_n|-XjBou6!T$SquC7X+MxGiwS{3dB&vlC~& z(B93{Cs<1Z7{MOA@3t<}{H??pD);7m_X2#!`KZy5e&oZ?N1!r+j%rA*YC3TW`s;=m zERrF}o5MZyv6F0#VBWH6tZQw54Q=FT~PblLLfO*DchNC2D%;qbXqu++| zt6r;K9z`EwmI#`?n!PUPR$UHU4$QE}a{z>tT{K-ZRkB*?B*rz|$THb`D|m>N=e*gg zQ(RJ{U`(O9f#%+@1XRkPxJ`2h(zW@ z!n@b|(RB=RJ6gr!8HcENrXntXYK2&Emus<3%7{vpK2akZ)6@&wxWd|7-+7^gVOTKXEe zKCxahNuM$eGJ3_(qSU9jFw=y3eiwcH3F(I{0v`~EomidH6MaOtBHsBnKi^h%B+Y#n@ix(y^Okjfxg~ZG z`?j-R(oit_#W2l8GYq?q%!;!wjDM8U4j1GufZ(CrTC}7?MB+Fvgpko}A3#(&Q3Yu7 z4gHL{E;-tQeN^*=9qXKBjJ4YiBp02KK%ypkUBWdjI#U=DA(N9ibZVz^? zes4Q7>AOVQ??54v{-UL&Fxb5g%i!opNphtIMhQWWdxYQG7ozN9?F2MR$Mml8X(QkL z`oX>GcKE^Azg7&Rm>FJzLGVZBo+FrSQzvM!7radFo`y=Q$0a4hFJ*y-i+fV}K{yzH zrr`ZG{sw)kvKw%2qlq`EsJDtPV#AUwX{-G%lUje8xKFE2uf(y&qDGjL0D0oHG7!&3 z`gal@{C1!6STyOU-uzLbta*mfrak;_la4Nov{cfMVJf^K8-Di&_t#O=${yx+a08*0 zVr5J#o=#dJYwG~aItjqgcTaw1szLs1xv9fBfZ+Wv04k%s;&|LAGRs99z?bR8#9_4s z_l|^9J9DkrFs9LTA$*$X#9qt0q06)bHi#B40OPGO!r+S!-dtOh8=8YT$s))SBM9I| z9)K1>rDRG^6of@BwktsU(3;`y+FhHi{l6v4<-I)Cj0HjQPo1n$F^pE25q6OP6`NiiF}FYw#G-d)x_x*h+f1N`qQYsI<~wrw)iRJh-rbPsvdwW~3dPj=p*{;gCR z|0i6o8G}8|Y&U$H>DCf-_|L80fKm0in%pVcFsPVoSb&{Y?+$zSSr@V#W{+Ty>}Ede z{Nha4mar4?v@$;iCC*H7H6=k~(dTvop;mF^fwY0NPZ&V91u!Bd>Otw- z=4#JODVdnNk2LPR9EVcTXkg-lJY{sAftTK>S5grh=fj?6Y7(mXE20XSG6aA|=tK-C zAA|4741Y;iEsoDOzOmapGQsf5qP4SyU1VHj%;G-!Z`K%%#!T?3DUbZZ*yCsG9&68MY2hy#ryblq7bXB3u;^TV_ z?&C>%MgNVqa6~yXiHD%t#;Bf?>Ju44ck4JnOT^(wk(Ej*HN}QG)U^d5Iy_?c`U@0C zlFnc3T<|4lCD|M{UuMq8*rsKWBLK_JxS`Tm7{!cCn>W{7g0B4)LU+h4fUJGOFYiPO zlskq1)h~f-=umlBcmu*$zW|sq$M67=P(D&zG+%6c?OIk7lB!t3Tdwo$8?-F<9QWvt zVXfn4_BLQ%7nhU=*5s+?(tB~ho$ z$rhpRAKX8L@FXjKcv-_f&cI<8w_OmLiw^!5`%VxY8$#&rSfcI+8rt& zAU!L2Sja2!K1v0%TaLV*?>Rq3kOIRLMnW>tb2&>vL27C|#6EbxXR@oU>F*DzKJ&x` zs0aMdKExGUv8P1sBug+8I7b=M4@*3X$1IRHaqn`f{LZbH+!TRdtM^-Q+~)fSU)=A4 z^2cMv*mjv^vz=|LGfrUE&DPC9+=%Yu0bnFGV`o@?!mL8Wd^6spt&VaNZ(cX=X;v0L z8Dt}!>}x}3Op@`vfz-fb)*!O-SKMhKNBr|5I=r=yEv#CwYqdaITD0{j&t5-ckfCY% z7cKpHnM|6DdVe#rmdeSaEm1VwlLGX{yL<^H^uoqx89F5Q>TuP=UI_b@S9)x<{uXEa z%p*x&zJ|9c+?#|%!DuR@Y4_clxIW0f5GisITsmClGkK**mCnqB%Vnmhs!+YX#mkkw zj|*(z#+bBCvB#&@((AF8tg*gataM$AbCT(Auq35Y93a{KluRPi$+?md1VtLh^>FcU zsqF&Qq1B=BS7jJiA7~%f9M?d`qb6r2^&7;0J=Q+FZpW#Xeib5?!>MO&Pw4W)<;Omc z?-QjjG?#+__KA0EWLd3T881IsZi;y0^}Cn^fi{)iy}bhfUCN*sgNM{=AQ*)&Blzq2x8jw^yTflsop*=f7`IZB zSD~HIzbcVTWbb8a)d4sgZ^jNjE|MWS@;Ix}FQX6^1nT0%x;FG{%@L3mrry6%_@evt zw4fcb_;p%$I@k*uUfT*bjLWc!45p)KQlP{%1T-VBkaV&I?)B)6=#6|skz)d6^!Tm# zt-N`Km+Ydm>OXpsRlzGtAx0sV6zclf_45Jg^)Mhx{-kov_;HT#7`;8zcr~!^Cg#lA zb~bqll$ygLqCOrD*VQR5oXeM!-YxpFE)9|S@heiT6%UqTzi}c?31rSWluREexbxXj z3nYrnSjvqe1+R;wpcUqA|L{s@f5b~STDR2ycmOFzB{~ZC!1)@ZtV-||_*>Y42UilR zuo?@>6!Tetl=#*9bcjDZ(;m`073qf)2k96Ry$Z$flNm+3{b}KY>ZxP4;jBOG?>!TA zOEN58OTux{%6rU5kXFT|X+xJ@_~mo8yeS6`c{b{){Y?WGXim+!SOevS`gp1VtXw}M z4~AF{@Gp>XCvaw+Ce>HFd;7691h0?ZGvUT^gSr(RF|8DH2v6S+n1LBcU=o0T3|3@IZrX4HI0;F(N0`v#pNp0PHVkDAz(ZY%FeYI)n!=l$7vOeEOJmo(Uyf6lr$f--CF+ksj>YusDs%g-n2c z8@$Q5%GYYF?#{bs&qZo`a-0Df8b#8V-2qLhpBGB2iA|Y5b{^rh`yx8s z3bq+y4(-t&pE{H8GuvZi9mSGbgaBeaC~qAKn@8&I3~M^3sn3sGGPbva1UWs zauug5hgjXfhcxjQ`&h$>%3)2P970)$X=x1TZ+^I5WNxUCU!l}}`#Wd>t z@c4 zLfEfFh^n(XDbi13AysjZ**bL&R5ujTAsv1z;TZn0k4H&oJ32hjpp!!y$<0e|RDqxQ z2dE*7#d!y13(ry>AZl%2~pgTJQ z9{}1?0mwiaYDd36k1ud*YMb3%E{1K}IYPaa$LN~oPg;DOS!AP1V8a+PE23c%tDIoEAF}Oi%Ou)+6CJ|XDlf{qR(MF|D+OX$ ztgz@V@|g^@X=z|8q_G3haj{Nj$V|Uggx~M@jGE!8pa~+q!M{%B?Z@L=pgHKrW$9Vx zCIni67C=I9#t%ih?c)XQ+-?P|3qO!(gl}S(L)`katdnyC$LH?Oy}46pDzXgLg7q~5 z+(~;|h=y^$rYu-|aged0wKbI(VLj;-ZrK|`q$llq)1dXM?LeUlTT%l5uC15L| z)m9BR9Lg0@iPDZgtaXV}^ro8syB zX)gp^w4o>b2!DF}bkv^|9uOK3T8bngl{68cKkIAA?eVa2JLF5WF9I;?{yhL7-aonY zyF=si9y9aCy#_9IZ83^9Riz}36tbLh0Zs=M59NxEk7N|f%F`e*H2(D>D- zqZjV5%{mFgTx#0bN4Q7II=DHm%8HQkis~x1$a3bnlcxe`>H!M-$xZkQ2vn#0H6ZMX z)o(eWfET4zcncqZhYoeX3Cq(U=;gAiF=*r;R1_{a$#(-OHL)hS=?MueF@Q>;@53MT z36=YGmK7qUI&cbewg-?&z1t`q)b#i*@OEDy&lJ(K={%^49Yd1hT7gZek)LtDd8FoK z4(at7pyo$;r22o}5K#U|T(3_NR_rRsnmqlAxjI5MzB)INN9UWnf*QQ__8qB%ihLbO z0`dS-Nms6lqcbED8~ zN4t;N9xRt?`x!5fU9JH07h4sp=i(1q(!-1UcPeU-fM31z$<~MvXMygmaMyHzz75}w z_$mPDM*E+1_7gK{u*tRK-_lk15rCm?6-zyAN1ov}U$<_H@HO~Jr0V~}p&j2T=A}m! z`hECcX(&6UGd$3+1g8rPQ=?T|n02)Tho+;k5U%Tkri?z&g0pQNP z1=x+*T$}uuW(y1I07zyvj2hbsZqScOe!N3515#s*=BEoz2{J<9ODN^zm0}Gh6nwz3 zrYo}AD5PqA&hv$;USVb!BFVQB4be61nFimBI8&pmeA>|05hZ#c&e!SI$#JE z5)pv3k0V5@*qD8Nd(#TpcHL%}mv!-oUzET8heK+$Lg33ki&U%;MF4!1;eJ5Whk~Ds2YLRZxlVznrw2}`m72YgRbWPSCDs6$Y z(xc8EvAnYEc-`?@GPH0I$AhJX*etOpdvnz5O@x{Ohe6pj-b|%wgWH&GvW`g6p=NaM zmwT*b_jcf^9sP_RV3hoJ=$j4GXW{Egp6)L6hK%3CE@%aPP%8+LTr=?g9S$SnLqR7^ zVyD-WK*x3_o8zcN8^1*$O5$1+XtsBm*rvQG2VO`cB^AEIGOiT@pGg%kS4+^cabFEe zdL^Cqr8qO`hy2!jllBLqDw3WzsJ+4V|JXbx)>69!D(e9mxGRE!0D}+OD_M${z?y`i zDW(uMU>c?(&!X8tttf|6NpDC{k@+E4lAsy!!D#9`GZ#AHX9$ZJ!^$Dil9Qi;3Uc99 z?KYPO9Em`^gU4=!y3l?+`|)hc<9O@lEG}~grLk;bMTwWsTmT@O9pEpNd>X!R1#B%t zJ{(#Su4gb9oTgm$5Rh7u#hghGm%bu?rP9@v{1wa5lYWcf&8 zv@@t>oWp^>xPw17*Xvs^z5KBZ@=3$4O#->ijqc1wk#2JCHQ%7hMQm7sKRQg&E7Yre z5Z8$`kwFH1LDtKXdvV}<#Z#O1xt?xI%v`)& zyaUh``4#y@Z?ZVcTQxV9LGE$x@i7c{MF3Y{&WT+hR6SO1_im8L($oros*_Q~p==Pf zy)*T*s8nz5_dm^JRzH&NZ+`%Ea#ivG9htTH5RlaO(bU?l7&qDo)0Rk@1V5(bm}uw` z^k~w0)qN9yHx*QPr*IW!^3zGP;)2{q?@D+Uq_IEtr#0s9EHLZE#b;M8W-4V)zL4u^7pPlp^RVtk)tvL^a6 zuZBLT^Is@%84ZlJ3tmQ?Rz4@^z^Zsz%KUu|OgWpl`^-psLK3=6C)^=j%`s36A+T!B z;*Q!0`i0!zQuf}e-L4?Z@T(5Yo=A;aN9~XGDIOvIUvRzz|F4)-%s0Te<}&&VwfCvY zGJ(ueYoG^O$%?EWEb{Qz z98VfgkSJ#poaV@yY7*~AYn^Ct5sz!4U)t+ia5j=om7R%Rrd6sAV4}f{8Q@#J*QA>d z`46K@$Pixa1n9FH%~0O2_g?w4J^86>qRfhN*L|(nR-h1t6=f`kh!zRwIN`^1sh*&wfPgn6za8CqWoV}6$ z)!7hae~15HTvZ$fIRO_v=DWSKxvi>bAQEyr!J#GS{_`XKh_TPlpu19xUr&cygv)RF`v@z#YCs#< zt#Uk5qigFB?~B-vHzfEXjyQ;X&w`uPs?Dm+5Q6)!4`1UK3oF67Vek|krlM5Fa!>tr z_;brWn?0KV+|ekz-bv$Qo^zga+{nVeioH0}C@ZWhtQL5DZ>YYx$b&nr0{bK4lD$MX zJ$59MU$WGx>2iriiA9OgKvcUDKzl)ZLD>XKnnfjlF@S`(#L#Y?_i>3P*jJgc zYGz)MDxbq3lAsU2F5KJSavGCNt`X}xD@l;IKE>0Ow^l z3JV=sh$5`o;~|p)0RvdTC0A7u{p2C~mygmnK}?B`?~*zou><~i9Ca8ykK_xN|NPWx zeU1(8v+gKN%y&buUJAGRaeTl__&7dt^aGo3N=t2OA0G)B1L+mWT=3I_AJrqM3ef|DZ6be{7>>~RjTgWuv-X{`OIgIIq7tY^0 zu<=n6yz;?)qzn0o5`qGZ@A=`_Hn)CMk!ThkYkppd z%Lz(&7znnO9V9CcGK80f)2_HOchDKyyajsX$ zZQ5nz7&u~IEX+9Tb+OE}>Fg<0)qrn)ZfK|7h1X=)WFHA&cF_Avo{Ng&e2yH)t!-*- zY7_$Xy8TMbfl<^*5ZI)$3m1*b94Yogq!Tz)>M!=jK__4QbiY)j3+gC>h%OoN8JoiLQ#igya=c(i`Z|2dduQXQQ@v1NYI=k9n@ho-yIwhvJYlc4ZvxOxw0}s` zJqaqjeSb*%hpM016zkA^X{DtL*_{dja~1~xT8DXdiynUss$dDb?kVZ*KO^bF-$Pe~Vkny^fsPPH5CAt9asA*7Bg~(uCsKkG9!v zCrcrj;^#^Qx->->mTOWoHrGaI4slnF^Zha`K`4YweVDf(AXF6h;ZwpSaYXE`Ss+8! zkVXpD8s141#BdZmrJUV_QxK{(#!Qwe(--%W2%`{aF5@YZP-uq5kWYPAP*pz@Jidjf zsd?fGwRT21&5-D5V3!?*rokr@Daa;!IGRE>DW5r-qR6(pX)qW96&y^24SifE$(NIR zp-zE+Zq3~DvjaP3A4#nREq!%5@Ne3jEFDU&-qMV%isCCN7Zo{_epwh`v(ykO8P>yo zDMF9ds(qMt*DdP$iQH)R0f-#eC_hC+Vkk-0-kLsC;dI*xk7QWl3Zlp5tU`Q97ee&9 zC9G%89M7jm8+txEHWF?+q7ARR5vZju(DgGrm$pO3=4G4H4k~kRw|taTq2}_cds35m z@Y&B_N04~FnpH+0N9?NRMTx)O-+y}|7F{=DEybp7ER?*|fUy6s zX{Y!*0(F=;TvkN!js1OZ6_6_U@+p=n{$A8PuYPQ;c|N!*9OtPQL7guq<3h67M?4c` zPJq}8uUr9(LPQ}gC@AZobelcCfNJ8Jd{QcTCS{BThOsE3G zsp4(yoTRpz>#K}42KBU9n(^`IUd6jw<@_oMZK#2~FjCLT{!7R%sq&Ss36SV=C-XX= z4~lvC24PtJ*Bw(9vVbKzl#!dMhtdsKBIKJ~|8k zH?K_K$&6@fGP*eG7TK5kEg-s2EY_EJPe$z~{gi!^u~xiR{8)hWh<#bF-PAd@_(O!| zd@jupbfy%ZbO&Cd_Yc@UkOn`=JcizP{ukxZ&VZ<_?z5I*q8@S@CiziLV8~gKv0pCu z+YCi)S_c9AM)7B` zUv*=VKNemDEn_0-xgEJ35v$5}DrS7i4ZxG@iU`JfAdbzpLjqAAe~o9_Z+i2}jAEWC zP4T1|$luY#+H8&pZHm=&nbs}6f|jg{Oj`Nr7v(52|KY=>)Uc-h8S{lCisjXnxAc|X z^Ax;j3Lqhk$@_fcm@wg0rD~%5=j&+4w#E-W@Q?UujyrJ~3B^$9GNgzoDRhH*KU){xUTFi><43V!wdWlkv zatV9EsggQqw_vn<>LMAf zw4XK>kl?awmJn+Q?JLo?d}&MI)UiO$#V}y?L&LP@jo$kk^ z?)gA&nj$0^(=GiVNJo3dI>N3+3SVNtdIklk&czQ2F3j_%w+&rB;s+1J@IT-G{L4(h zo+50C`z=l4EULva#z5~t?^+3VHenYc!mbbq#??Uawj@A12sQ2bsL>xr=_RK=N)HDN#UUOoz_m6tExMTIyYmG3TTI(UuC zhQ**NqLGmyD=MI(Wmw86lIrM$Wiz8Q!?U1-sLT-TESU%#H2vgH-cI@6<<+%U{!*h& z6_jRM31{sS0ZHBiElGDcMW8>kP4ni?<4^a|VtMm7?c-aMELG|znSv>+hFmZ@<+rqd zJV`Ide~DWk;fnhHEX&dQgUS-5cAI|Ak9YO5mgaZjzS8QqmA73-!9QVFVeLBaicXbe zTjxhQ%nvWFmsnh#7G@gDreoM1@Gk=cIwcvFG7-A7cSe2edqt89A(|zQ}Z8@&&ppwC1d!v9A$A#2t$zRkJqy?EW}#wkI>uN=e^6)4|HL>sBEI1 zQxC#h{*_Z^qgLeM=J^!cXeyFtTy?hwK+K4tG>L#gGtC0tLDXu^IzV1yn&chxsmcZs z#8{`k&<2h4(d^p$?*x>u+0v!w<)Cy{2;UQUV|Kjavk}cH@fo0CH7!gVTPn0LGv1uX zpQ&BZok_;SX@*{4BwrI{j%ME?utXKC^XIJSR_8$lw>yDTXC)PJdVBdOLJB1j(F}@DSnS6o8#qq6}vxP7>@ftU>G);G?^HLiI=}U zV{U#Y0_BY!7#bKl*(7u#cGA9l5fN5k0TZB#1Jk1jf&@Y8-K(z0O~^noG(?u_S|Bj9 z^M>${?vRcav*2gJPasnKAG~)ql9s_x%24VrI*Jx*-bquK$Kh}zuMe7aGnLDq#)Om4 zz2{itD*hFzp%H%+djfw2hL65Ud?$CQ;~h=ae5XmvWS_Cc!5%Rq=X$qh|+f~6IN z;#rG2uL+7ciaARQ;^gH+0YdFumK3!$oVm@p%^B3(3eT#+UZ+o`L+4*mOtt2x^S{og zL2*;Sg?8Bw0cn=_7~Q}mMFW&-|9fUP5aYyU`|zP%Qkg+}=-sI_6Co}tNUr|7ZCK-~ zv1^rb$PczS>nG_C8n+pWD^`4T8-&p@{0p-@jp~OeAJZF$7nMftc-kcaFTxI=K`Kp* zntr&fOKt#|yyK1EzCz_D|87fJ@RZT~2sdGErnOK%$Jg_tDFqXb}5w3@;E|FN>K7`4`WQT$~-OuV#$)O)2# zW7^;iQKy)4k)(!Efg66>JD+;Qc*S|e;VQSQeP^cWezzIwW!&!WMF-=W1Y)BA-85#m+%bql&>P~Gww4UB1yq|99WJX zgqRSueaqC3(18D{|7sRvlNJK~%J#~Zjh<=zP2M+Y zv`|d|0=y?*jFZZh*?Yud&1TK^o)WX)gwECPGbU*%St;3k^psq2xLWl8Is)r)FLZ7> z9#~-G7k2*WW%cmNA*R<@ms1(KFZERQ1Z)=(F@kR;HT}%nYE~!?@;+&`v6a0_E&d_v zt(~h|dTp)LQM{_{iUoSB$DF5j{o3{XwR?HDMEfrZh|CoIUOb`TakOmdzE>{Y71Tq< z8-V6h)i!5}Glp&#UXOf1D5Xfin8sNgy=Uo9d4dsqf^j02FGzu$6@+$&4tUc?V^63k zp(LSH6A@vHHA=iFhuEG?H{cEB`e|O*;f!Hl-!MA$nzmpnNljf~NmfzWs|cr=Vj1Vi zn3=-_?Qsw=-h*vo$%V2!2GpOP`y9W)U)@GQEo1As9lRaPLgIuL&bh`!_s}JB8m)}< z`>0!0j;R}lAYSlAi@}ZiUR_84d%zbIDsuH?r>o7l7y2D~#~8Cw^&uQcYb>2%C<^)LJR+Z+`LM%IOhQY#p3rLB>%)x_GMjQY zP{UNUMH?}R$n49gxa&EDee&9o=VQyzF{be78h+r}<=YBQd{R2XO%}*>ZTBGVX<7u( z&gcs31)?8qKKnxhqpf9INyGxAS@Zrd2(9m5u)3lUd>2^EH@a*tD>6NLF)K^6h{S~VncO$h zV1`*m^fw`kFdSLY*q2(DVpd7-wMO}{oKzv*yUZW>x}D1+-h_!iKS!wGVla}xTriPl zFpzV8W?a2|rNM&FNPKh@qulQoQ9yx8UMnk%@$-isz0h5=(u?&8dpHQs9%76n;#t4S zcvol)Wa>O>hR~12?(t6(hU{q72QfpM_797YNiraC#%`ydNNP~>-t|E2>+i?9G|1P> zE0E*)t9s<-R1>}6^LEyZ(0+YYIqme&x3lGNma-N{o?$%5Q%nX~#kftbiMkEg>JTZ4 ze`FNx=pWrD>iFggwAv|EmCtwjiLaofzq-{h&IWXF5)z0pX6E4^8_9j+uP%5j1hWxc zvdUh4&bVVvc0V7{v6OtNy}%fL)ECknT2FzK{+i6+hA>I04acOI?w<(W`^^_S*ssct za_Ph=PSC{oYLJ>g|JHoNH~1^mg4k~gwlHE`z5yctZ!BEk*7{-)1{x(7GMR8f*5!a| z>lR~jHj^!5^AHnsy~rsT1KY80IS(u)G%*HA`^tJ=)-R0P%HZ7KozZNGgcRYc(k6+^ zM$VGy8yNmyaT|s%mH~hy)`;K&7l7)mORJ|W7wx4Iop60Cv9ZgToH?=;dl_CcV*uy+ zV5Xc`suOqWfF4(uvZp@!k2m%EgBE|oBiCLzMx`&u0-c3+a@LHZMo*V4%MsfbKOK12 zh50S-hgAb;DZJc2?5+hMc6#1U5C|i&d!H()bEYvUm_R#*Zx_v2p{HL_sh=>*TVbv* zGw>w%G=49`c;>%_7})RYiW)q-LiM$(h zv>UXE)|P*L^FgxpgY8VZ8aI#|^2DWctc|s6_-6|B6qn{J-*22y4vjkhaC}(E9b1HW zqnkjGcEQ> zHN!_U0t7;?zihC5W&46rNC(=}Z%yUL=k%_gX*sJ;sN=OVe}krDw-XldSLz^$DI`T4 zcTVMFQL59}d{<)6IsQAdT8ekz&#rk*#+YC-fxEYKAI8kS8ov6AX#rCXVaF+7a^8|u zSIWrnPDFN8?vq?Gd_~BbrVTZ&n1iC7-FI;wGp`LHrM-YKks;8)pcy0t!$#f0@{CCn z6XMh~ru_E2x50p1JO2UeqNE8*u>9Nf7WadnTccmD`QTcyaTfA@_Qr!E4b{mHBe>1J z+&WI@M3vmj3TsYAB!AEI&Sf0kVrVM`GK7L5WSR1&&8wvDgDR;_NEQc(f0$ryes2EK zXUE%FvHedg^Dct5)^4HxVDEGr#=jm*O%AkGV7|Olzf3=fhP6Hu?Iv5Imr_si^Uupu z{yYJjb)a)|8JPz@?xBZCSI6&fu3L*zy+x0R?N$26G+py4MO=2x6hkgI-myw)wlV zi|cz;!YH@m#;NiJSAB60h0q$;z@A;v133dZCm;X(`aqvj&1tIlgPy4ruoM|u>>a&B0et1JpsSD&eQay4#8;Q0Ii(ntW7L!lb(<2|m;dfQE6td)WZ`%C5~z!(dk- z_SXZ5XV9~g#e1jFj6NgZn1J0)T2hvtnDJM$MAk8!?+u($BX)5Bwf&24jvGDGXogGY zaf1f=1@LKI;pKm+o$^Iet^CB)|3={FDq7}=ulWNj>^-Wpf)GS(5Q zPgo-H3aWpmSxGw4bWuPufu6~%eq*9;#;?BVrS{$xEB%hDwK-Q3uB{G~>Dc(o41*(w ztA+sT<;^4aD^XDn;PY)*QME9dslxn(Fd^0$v0$P)Dx%U~{~P&E*jtoc#$84`J|@iv z5HTyOhK4VJz(?D;kpp}Le73^in9Sa|z#-DMNqz<7O)w*c!-1iVU!=IT9_s{RgQ4ce z_$_B;iLUQPT9yhVqSR4q!!881E0GL&4SCB-dlv1Tbw_1a3XZ^SvU+-YRV@~Wb(dvW zth04ohH_kGE+~kf{wA8_B?aD9l_YdXKWmk27?65i^~F7?{g*vJ#GxT3*Q`vcJn+hFW&G0tg;ApAk0myIHNjVd36=?ItdkoAY-4)hBX^*q+wOXOi@; zOgp8GL>91>>or=g>yG#i)fTqUj?CZPCYKrz1hTELjevbE3r)gVoYjCTCCbBe0 zH);q>g^o%65gq-%o{p)GsR!M;j>pmVIMgDy$8^$GNo2UKx1bMY$OX-`$}Y;jVJUV< zW2N4W0KY*OrjFhr5o^JsLk7yyh~f>3cG+5t#`Uj(KIz|;$E_-@+Tsu}=hDHF4;GkQ z-Q5wpwe9FF6>QI6Jb-ZUAM!?A2YCZTxOb!t^tT&*7DaT#a)rR*I#Cf(?#yp4#|8e>9Zqz;NGK!vWMl5~hx)S-vVYRQrF7mUGbfkbk&# z+*5>&0>{(1$hVnRmo3w_U3)L%koK9uHRbb_0?4AvlMtCX`j5wAhfaB2n=uOyyitRC za$_P0RN^;NGdUlp30co)yI<^FOFBG^#-NrnDlP%q)UA#$keIi~NzQ2q9c)egToAsV zW3=*=jOBgB&QGNwL^b%QJg)LV8NXhjBMNT8fhxw3N{CsHmB_M?~~Yn6ml}9`P1Wa3uHD1DW=F&U3T|* zrxGj_&t#`siab?!8TP7++LDgKB2=-GiCN_!Isg*G8~x5yg4X(@N{R5L{=>~nWRd3q zE4g$Su_>|LP+M0sfFWd8s*ml7j=AC`w}Wa<=C+@^-?!W=zhi0t5n2LSHP+0nSn1;x zyZCqOhac(mW|M#Tv2NtCC1d;z$P-)*M06hUpGfZf#nzFAT zJG~kX$XyLQl@wDC=6&e6@Zo>p;UXw*c?Q1MJ2m)iF1H%fPUOeDe&29DJ*E}z`43<@ zAd?p?`6Q}X|KGx-lgeslyPzMNZp<^;Q7mD$nH(glfF5f}e1JU~( z%5xR1YDff47>db-s*_`cbo2nM#4Dy_C0CS(*hi%`bm{!@T~N}IN-OgXvPxMVSn3~| zTT`>i@@@farO*e5OW|m?#bEb6&O-eUJJT}U-`TMu=}r+v0ZB)y_xPM%)e|iroXd!- zh^xfu1gLF=MlwK`!~tJs(O>kt=N$d7+%LqqlDxtN^Os%Pf@|*pGl!9O*Es4RAw19hZf^oV#Nq{es7)-ithAlnC51r3`xq zOj!ex#Iro5SBla~Df}D)F?EF&nsp_HRwE&oG^iQQPxLtiwrjj5=07`~K%~cX=Twt3AD|$Izk#QVRNzUyf_{`P%Sj^x(1{Y1-#W*tH9; zQV}GkJtM55dA3$6Re>e^_M6To;f_ZPC0~i@p<_B__(j*Nd)sw>hE3w>hes29 z#ugmrQf0C~=U(znYBtYND>AN4;Ap5Br|@R--d_5B+2?|@$RWZEdH_Ld4o@i;lkOze zKoLSnu|l~*nN7~f(#Udwirra%@s%$dYM`9C5mtm}uUH}{dg2qZ3WMA?bUmn=szSqN z7t-2URh#KZ{;bhDUvw3n$_o!G9hL9IRc*J}4ij9Vz>%MtYagm#k;7kC0i>ljeL}bD zELA6ALXIh!e=Jx$CSD}=hP;C#DX)=qxn`vXk$vV<)`;HSMmu>T^1ONbhZ_I! z96+mbyX^d?9ysJA0EiSUvdv1Dui}V*p8Hq-U7bj)ESf=vU#4#T^?-S1mp~VVVqT0S z5mnR+FWPSxuK5m>bP6AQmWb5PyL)<+BtdD^$y*h13->tdW1hP$=P|zvJefs2m`?|l zB^D>&A`y6l+|RX-WlvaX{-gZO{(;13Mb&32m&c#>4~cSD>Du%$(Ruq++XYWY?B6YO z;2~|+>;qamwAis+9KxfMUarr&vc)3W1Te@>sbvPACVq|A%^|=W7JfDFh9V?2a{;c8 zE_n0l+W~dFf-&&B1=oHz>aWydT;yAvaBxJD=<=iYi9uD93fDj(U?kaO-gyinm}B{v z;gJ>;o^KGnU$D7ztM{UI;RH$nFe^}e7=fe_x`QI`(GIjptJ zyJQPW{#n_psg8-5KIc|R-c~YL_JyW@m=Q0@_SOEZ#gp}uH38p9CmL9w(%Nv4MfBP_fw@ zIH4cInXL6hm+SnT{Ko=egNzbKT448WdaZK4)uO|y!%8!S5bur%956$7#aKl6F@!H8 zNLl+oH6pCz@F?Ros+20HS;I#)(vA3)(=5&0;ZB(pqvKYl1 zzni-TRS~O#(-DCY;KYwIK0MSCSEmVS*r-}sk)`MkcfEm%zeOfS3-mKXsU zUFC^IB*wq2h53QdS2zXF)oV&DAh=wL0+{0sE|3M6=3}n z@dfn%-v9O_8`q1t7r*g7+m}7N-Z~xJWJDll=5@@Y&jN;yIl3?e2yE#_Br&(ohjvrP zK>@iPV`g@jH|857HV^fWMo%v=U>9V!*nyFf^x}zzYP>gF$-$F%roaf+OV-c=WIX#2 zU(BCOX`d)S4efy=pdXSPS(fO(LtY(A2VDKW>-gg(^K;y9RkvSk%>8t1vW?f6cl8kl zd~5_t2t-e|ku6t|iaH!?7PApgPM-uicu|{RA zj(kUr`GsGgTK+~Q(y^`rdbQc&-V)QE4@r0Cj)v!zobP+z_tt5u-e$;-Ke8(6kk^FP zgv^mX-vO!^Eme9GBF+*Tcpc2Ac-WV8ezN%rlU{KjnJiQBc(qL&E`J!v&5{rnL8;yp zcX3v!pFX(oOSl2TbyFARenZJB^mFjaX|zR(=;S4B?8293oZ+l7+H$n1feW_-Il(3g z7b{oW54$4FxsRG~as=T-LX>}{n9mq>&Cy&;j63IyF2@YNBmZnqE>zNYMY{|k>Q<I*tn{ERsg>g8NY*ZPMT}Qdj(0bsv9)svlkTrXt&a?VJABRqV<-EpMa}h9}E=X?` zcPswk?iA9$=kEU^!WDn*MJJXTdMYj_6>1MxxB+?%>Tb|8!357Qg3D4NLsmlppicxL zSC_o;$oG`-rVKIo#VZ4;QQPE~)O~0@44k(t8i>SwfwJmCqj+l`kcV zI)#MxM9<(7fBXPOQoHwOFKgqa$nc*qMg7@*@Kn%z4zu zjA$k{f(s_7P+77vkN}lIKmy*AQr~b1Z|^I|SRu2~L=c3d7giQdYL8J|S2W=J-8$A< zRT$-Va=cYu^5e2r=y1!jxNAsP2_)8wD9s^9I(5DPgC_pJ*XYel9|)gL-+WjAjiexNoU)&e&%1-UYnLWd)12xOx237M0$IX3rw>Lrb7C-GxD`ziF-1qVD|vA>5prvcQ@&=l}#2}WMl#?B?%z4?gU zV~G416{OG=3U0U}o`#$w1Am0m!QZwWMy{-86aHu!Y<284LltM3-Scr7elD*{mIdvW zi(Z#&_PzYEYTe2kxTjv3@Ds>AYmg>k(8d!fx#m@9wgT|59H{+GJ)xPwoX4E^#WxnV zpM@ZHC#+4Ay*2ygTGoah^sA+kN`#4W7{>_NepRkXL=gR^fuL9PIL45Y!tGF-jpIm9 zkU=b6_8~=fi77wKHWF?0L>xW^Qxk+LK%f=yIg8q$+8}WL*DV!23`F*==1piti*cai zYJZ^YOU}LRfe6=(OjwP`w`mc``2M*Q2^LOQ=G6ni`HTB+DqO)x+N!fPD7&Jit>G@k zCjS`X5?gxvw3$OCT6DDJvFoZ-nD47jU;B~yCQ^7ix76H<3;N|TKbg}AIuC^#L&yy& z2zeVyz^^Nu^cQdkK4#CqK7I?t)SCadZi}gjuZeGmIcxghRHR?SklZWzW$NIxnPPC< zV_C1Z#XI^7?T(bWsD*260iqn6xu;ZH`pPdVq>lpHt%9p*c zXcv-<3rg{k%h3B(lxW?Nc`}v~y!VkMo1Qs5nFvU~hy7C7d_qAvNM#6-v$7CKo;8ob z7+!*KLcc;OHZ&ViR1wBJc}y;3Vi>u~aV)k#YYaT7R%9W&Qo39EvYdS9N)xG~kF%~? zZM|QF7t94IdI`};NFhk7igLQ>+}#U% z2VS4#Pm4BGe;$q>FB;p0ZGcs`c8_V)X+ZTCOAPBIr$WO#05>hwXt1h_i2jW=(dS4T$CQ;c+Be4h?2v*|O& zMXqOK5#Cwinz-yx;xAIGq&dN=+czD!8_7f1~ zBJxszLah=2&3b9!(@(sX3QvRG>L`mFfZzY$!Y4ezxJT}?bTT8mx;SeW?YJ^|ssbJ| zNvw3szeE3ntKcSFjKK5)^~`74&>7&Kw>i=j!PSx_F1WQ9=%IArJ!G@h8&Xz{na@(Q z2mN|V#OlluVv@L)_n!&IZ0+jrDwgvHoMNiutK)z2-TAX#@89m<2BWnluME!9elG9S zUGrYoI%B&rM_Dns`c(g|Jdk++Z#T-bI%1j2vu4B;>7PWePsFbL?chZ+RR^Qz$DKJ1 zyzTLH8S_qQmbJvs%4ehNZNon4$JjB|an*5SXid3GV`6xVH4kaTHdr`u+dcXq)Gmx$ zgNF(pkWXowjxhP}upml)BiC=ZsPNdLZ0!g!7;=pmq-)OHQ$K{nqsQ2h`y~Q# z+V5f%*%_W?#fkTLuMsYs0=_GuzEzzVa92drtx`}v)TUBfI?1~mrB7|ER!libc6_S- z;zi3blm?vM+FDALGRh|t9OFl8z|8Tb6b}?c{^8$gUfm}c4zSVPAcr(8jUrmkJRn=& zF4hmt6c?nO>4#fk7mfcDD)V;CU5)bfHI+@_5tO@085ig7&VW0@XL*b8t=ZjK?*t`( zah-0;QovA5QH#X@EeTIHkLfq&@{<#V1xgBxi!uQE%G|lPAKBca?qC0`J7n69+NJd= zr^xpi^Ofzys14ATC4dPyl<*^sSXKHznPsKj%6xtRSpc&a$Ib1k@nY*2T(@Ko*!&KR zAfVVd*~6zL6M`H1+~9qoQPy0vk@QtvW27t$?8q*hf@C9-zViMPm%zemtgk9w^vV3c z8ije;p8K#HG`)focy9&H7`5t1&A^}27aKQ%q!;f3Q*3v-=}{#|esRWS2e8Mc6 z*vGU^u6n~vvhg)W?92=tJ;NwPB4#nhJhLtwqX;$3FfSVFTZM-g#l~T*==p5pPedau zc`%xqmX-q5SWh|S%t~jeDod+M5fl*m34$^_Ohgc!Hand>c3f_h`yA;3?Ir%c8cU-! zhhcQpuQ?pTzW_}6*`|t4(?eeSzy`$RaBzg%8&T$amV;Zj`RKOQ$a>+iIng`3h_vXm zbnme45Wvd%@zL>77j4e-%MRNV;p(en916m2CX(yyuAA&@x%FahKN6Gi*ilfKhUK>3 z$2|ell3`h+A#HMZUd9@vwi!_0f9N!OUmg{n3Z7&or(GC#0%fTkiWqP+)KvbhpjFP! zIezTObd$!P6Zn`ZjHOMl63F1qFe71jZ1GSEnN8AHHx9(bJO1cv4#Zg+iqyGi2giIS zyW#Y2OWeTaqqF#k=jK1vKBl24uZIiNz14{0&s_m*K`I9*A5$BL7M(OQgE1P-s+t@# zj@KMUbgshS5OKpUb^EZPRC#$?xeS4}L@#-q3)fo_{BVCmsS$bz20Rp14gp*|L_qDd zDP7rXM4G{A953*ZWlocCdzYKIOHSI}Tw(;y9FX9RvK%p<-yaeKJv7e~q(?7tC0EF1 zkc4GjK~nPZ>&QhG3k0|P50nVhZW}%rmOqMXW*9GMIbbEgn-P^H466qVd}7y=f0J5J zt7VxV#z^SLfA+!mM`BnS^~`{`Pfowo|DHilfTE?esE!zUSSh$-K`SAmL3Rn`ZA%0)HDtXnKg;}__u|9R+I z)gO-vrraRg(u>8C&Jdjk6=!y_eG%QP#@5pnwmeISjZi0LKs#=Nr0;M0OKW42hh|mm zKz;DKR|q(8cSA#qiwQqtBj;r^%Bqq;@SMHG{GQ5@aIG?`c_PJ?3DVil0JcXx` zifmZ9Ju4RS17t1CEX>yBCQK0eO(aS3x56n1&V9X-|Ak%<6(#yUF!lcNgo_FP!DTWg zzGAqzG^shcs#fpF;6cD|YBY*@ZKDkPXq_BkWxq5}@tYLhzejL0{Cak0d;QiZsW|3Y$ys+I3b<}Hw%KPdA z$hUU30diA|&l%8+bsitK`-T!)1-xzGYAVjDi=2&QEcqJJnV*T10tY*-&F{T$T~1dv z+R*NG9sqdZQ|MRT0EFm7X~6z!s|Y`do2jb7RO$vUFCxodv*S%%Pi5Eq+WzsEO!|Jw z5AB|dR(u(uiT)~5z}q;|H?5IQ0jfj`Zwl4aMa=(oH`C7OH|ja3q8n7j@=}y$Pmk`A zU*%!X69A%<+5wX6v_|4TyjW6ZxXKN*3DjIUI*KpI*^i8u8=JXM`_TY$wJe6juR@dD zUv8@Xk^2Yj)r+ivT+C0Is|QC;%@$Xv8-(A=212Amw(OGfRfEu>5Bi5qj$LxGn%u7& z|DtMU3p>v>P|e&Fj!}4bhNxL_eX9~8pK?)YV?0EU$@>BbJsAHXGyI6FrkwJfofaAB zr2-H>2;ACSsMp@7t(}orMYWkX0|?bE=d|E#h~&Od`QyOXmakXO39aO*ZF3zV)Me-p zE*SRh2i95)a3=cQTKkp;Z4JCk9D1ar(OI9fjVqwS^#(os8!l3sQ>Phi9ZVF@_~YpQ zdi#F+ehNiw0!-emL{ulI+M?rQM+IvrFbqTe7bSETW&CA3%B4m?$pf8ec#hndJ9{&9 z9opN*xZhH_`y(jwJQN@!@1P9`P-!5pD*6Q8hI1MiIN<61fLiOBpzLi=50{F(zH+B* zj&vyqAQbIm45U`A2?CFqGeOS1JF9`U7DpOLN%=y5CmMNew<*pMvCkLp3YDc3BCC=X zf;NK9FykWf)6|^sTW-*DkSy+rTbElGm?EK}gG;WX%uJU?L&`gI0fRSrZPP{A`|x9L ztz9@W=M{3mUn^(6z;Wz#(f(OwdCZBc0kN_4v!`+gbe%>Z4%uuzy^DVMf@`zLOdpwQ zVnPGX`<nZ+86pZpTSXW+oaF;*(#Vy@a_r1m{7tN?_M*Wmu2J zmk&VTey7%YY;i^bI8>O%&LgeHAu88&NP$(I`fJz6o_IbrZSzvNH(X~1TQve4KQtM3 zb;rtck_m5w&pvJ$oZy`U+EhL`!-eC^sVbHvZOi*{5$NAm{VX$1S0T&BR#kO#8J_;~ z?ZK16-kPS#8R>=aO7V)ZKIEsTe_nrskt&0$pCoFYKAe@qp{-D!x*4(KZtvhv0M<{k ztQFR&m5>i+zuUk1fxUbtSCk$Yc7Nwkc$!764*K?0;} zs1~Tq10pkHt~N=da&|CA7Rp`q@~`LZZs`Z$el>gLUkAh73d+87KAI-1BnIGr z3U2FKp}#o3_35BNW;tff)7Hzs6;i~HsPB^uo{5DkA(-6v;J;UKUc2vw8-)1npU`>7 zw?-QpTUPe8T$sCl*mxHu6_qaHemYf;yIxFP{szhc`{&;r^rFzoROpMI^6LVLfVh>{&R~|31oeE6IY^CbW^{?3rS@RNxP*m zG^whZ^RI=P%vN>$_&)3PYhaikZ_w$y^C-a^+L;z+P(#65MbasGoKkxJD1~T~ zVK5gEp|C)RCNjTTm);nsU2*6!^_p$`JQf z{h|0VDI$IG{BFSnC4a5Xkaz zXOL@z7Zn1SK-Lt*uJ;`&*(E~7R7_QH*T+uMT4O`*%0IpDb#P=G!Q2CUOON8H>~LPB z|LCycZ@o*YW05LuR4fBfESGcnNmiLvdJNd}4Z5)ShP@^T;27RAmiADWod*>`ywh<^ zq%_vMyhkkLR*7Lx=&G>!ag2&RoXN~7J+!){;vF(pTeHR7Al*&N3-l5JJ!Nb2c|F|l z|B{4Q73F}jo({F5s3Tuwi)G?IX1;e*|GZ?7DOEw8+a{)t)NSb9%Xp3AiuJEt$eI%QaMb^#GUG$ouG-+U*_%CIGaWi%CD%wV9w{HTOgBhp7g&=~t z2qumM;NW972>q2!x#QQ2)1bJbAZZJYuk@iX*U7cQ6%Ecs!V>}n0V3Kazc#y{Dl^Vb z@&T{=0mU%4YD`r}R;oNt_pZlp+Hbm!L7YRJ!yl))e%a`VJP~tGD`94qCP6;1V1XV# z<3Tdi7j%-(U(1v08!+BqytDbF*K;go$2y~MH6!Ic9y>;)C2mKls-LN6n@Y8J;_DXd z0SH@m_2?RWKtE&K)f&sk9c)bg$TlApmq{fkXe+<7KGKsJUht=qy54altTlCCzuJTf z+M#`z>R2P|I6RY9&duoVzOm8wJ7G?`D$w{&l#gr(Z#&9kbJyHg4S;R^ZIn7&SpOCB za?Pg3M3GjqwB{}8)YIE1i3eBq;MV)SvrOL$^gsl^gNx{gfI;VJQGD zvH!~pH5l3_uC~;bAzZbiF4*z|@U;2J@Mq+Vfd4RI3iKi(5%Hsy_Ba;iB8=8R|8ti9lm5cg&Y{&NA58Bz~{?I(fjMZaVdj$Z9 z^or-mbeRVGP`+&Nl$Q{5>s>@NP4MxMRf5tE)3dqPv&*DA6x$9+pWh0=w zsO_L$%niPo9E#TuB2C(TIj)|Ep{HdaWr`3I`nX!@SHCmiud&Zx)!%KS!<+5Dpj!sS zIAc`EP}caI^9;AWIu>Yl8;=a&Sq3SYlLo%KKvP`%-bousbHUl6R)cb<1sHGc&paw= z+jCj(+ykgCgPe$B4ZSAM-S!yz+Tv{FaqVAJV(jE59%#LB9$R&M_0}97@F~&upU0b|Npw0}wF=dmn0#>W}KBlWVcf zL745-zQQMzEYjK6PKB>`uY}kS-!HZZ5%A!)^1<$P+{E|1ruGgKl5>-DJ;|4ung*&+ zsl*lR8p5F56+bJ*sX3dV%TR44m7FwDZg&>ZG%K;C7!bb148C3%Zh~2&KX?~;ld`m* zc@ABgx$2ze&my@Zu?$fRv3EYwmEM&eB7(1_$`O*JOB|%rAIv_UPK^nF%tHE6-|T_UCs36rPfrx5zk$Ir|MBQlr2uBx3Jx#pr{~n;grTI9pxR zybTU?2IBTd%;aOxxnz^Pfaoa_8##@lxkq^Ifw9sR!MVANww&Xy?WC)Ta8sgWCFEWBB1-d!E-KyJGtU#zSq8p$u;O_+2~wvCsct2@x1gx2oq< zj?f3pPg5XO0v0JGvUG#@X6|C7bgv{0eKFPiQ!dzBRv7M_Bl(N&m`5_n38_e^NZy7Q z3M$!s-I2Ep??sP{my1gNm$HvDIGt4bvQc2F#?1D^Y09L^Qn!XJ{3_JumCkf1p3?*u z8f+>%blz99DG4vmAR%fL<8!}H1d(8$;D91yx+s!PD%2|(FD3}MmzAyVoDVXoZmak9*L4B5u?NhZL^m`nK0(UJ=~_$uyH=ADp+=e6>U5)efut~ zS~lE@0%OT7Qiyt2i&QyZHJ{4OddxWqj=Tz~F06pf6XN;4T(^?eUmGfl8SZvi7jpX( z);4CkyNby%ty97lA8xGRh*vI5-D}!wDj%@kmqMcRb|x&jO6#Zeja14vZW@zMjmWPB zNB30|y3$`-blG&-j5DN>7dP!W`)7l{B7`<}s-mX$i{pIr@cH+`4F39|WhlE}v9hL? zYuIe0_$riN6`7eal1OB<%S$C|aE6H&elPoPJ^MKO_--h}tSNef>^Ij}nQ+)wKpXf` z<%W6tN5flQ@hM39_z@2 zdasJRKG1`lg7BlV>2_?6j~At)j~jLLymbVZ;cE=4qx zJ>eNYFEZ(RQcAy|3#-B9>l+g;ld){xq;+VHKyn2f+Gw^K5+;2Ed#geHKG{h*!&M zNK%Q_r&AZ_^(XoDZ)(hVBADjX=+iu~Z-Hox;%FqjH+p>aWHez(J7+ntpF1y6Ly%+a z?)bZW7VPZbxHl^ukwqme=%|k#9NN_#?9RA_Y?yz7m5&UB@<{rvWrCo2&{ED2?{0Am zXE{k491Kxr(z;}=|Mi$WyXaT$KdA>IZ05+xF@S|CBs&+aZBAki?!d)w7g{ut7G zF3U>ztcv5*10-;9cZ?sm)DNQWT^=+jlroBU(jXhc-9+5n)zamlPT8tUQvT(U?!v#r z%x-Ys+f!rnMyk1~t!clBP-kvm7TC=bUT1Aly)`)1n7#@%S*fZ{H9D?}v@H9`RIU_A zG@d%YeKTE=D0=%z<<|)_le-IR9GiY9yujZueb95$EMD4{e08Z>d$=NY5WY_=r{}2 ztB_wBUksYN6fA40+3C!>TR-?{XD)F^ozro3&|!BRS-)pDJznx_um7#gr(1qe#A^A~ z+YSm50^ZYfpgd$Ju!_d+Luwi?x4AK$T5Gx&?;ifm%6Z$aPjrd{$Fz2d+=t(NU%!ws zwitNSY?%@IvYotLr~Or#jqykv{G|)^bMW=!$%Fg5O`DN}K*VQ2ck2{@xYBZt@1x=S zjne1uZiRfmXAdDBdeuWOk4CNAyOtM@oP1t4m%Bi-sqMtuzPJ=-vzHH!84v~v-r8Ph z#{B#ah=TP`#{WmJ;AID3Q+%TgP#C}xW5ke;kD$Yn@<^Qd;p(t9)d?1WSj!F~vHL?| z<%Ok?^~o@09JaHmKSQGDQ=iU1l%$W_u#VH#@;z>lY&oW08Gah z)$YxIEX(Q||IAUF6sQ#eP@!A8gXKveGMUP2%ijcyi0?BJ+Q%Va4|cH>T$}h*Dg8@I z(q&yYogPi_ncN`8OL|#*D*$tIdsrg zt;rA?5j*!#ylS=T=~=#8$mV=DMo)0!uOd@K&zd#_jEAvgx0b!=m924wN9ki)WPXJI zH0s7_heU_At*lf}N4gIsqoD3NTg*4@-<5>teklFx9O>X>%C=g0NjwpL!EjF~^+M`J z2hmpp@|sscNMo*IUEB9uZjUoJI=h?-r)3 z9(kH0?X&K)+GGY5a=-#Er1V{pLsl3ei{+oxXpqXr`2eY9`(cT_!v*>&++ zxUu(2*Os)gshr)uQxH3F`J0KZT}4)yP;N4<$p_TZm{j8lzYFzGDoXzv~IQZ`W@91=Gwl;u;kYwXNxMXmd(MfG8@?OX{dz@1f2z-x+5l(xZ{_>WG$NO(6=VBD>bbcJn- zNRQyc=T<_WnNH<(Zwv<`PoTtz<=2GftKrDZZhPwuU;47r+36XS>VMRF1YbDTxMXRR zL-^y~{gTU{D!m9o^>rV;Gr-GS9sxBP9Bz9QA<3XZ>l`b?Sjn6jV63fQTv+k4j$WoX z=c3(WJcO@07m1fXhkMW5^oFckF_RgF7dd`YX#ZL=tf;tVTO?#2zF7Hsn)dS{K$-DG zas5j-8`$sD_JSU|T=;YMbBX+1W~Cr71atTO?t2@m2l@7^p&P2ga6m5Mc%uJ$%^u*J z&4|C1@>6EEnO#@d=bdN? zgT8+yr)Oowh6?CBWa$Nt?*dfpyT!ZX%{!tszPreUMCKDgHgi;}F~71TGr*E>i?q=h z9^{b-SN`xl>SudDf%xJqx5C?oS0YhX-ZpJ=CCa*?T*w82dC{vHrtCueXMh`L*r9OW zCMzCL=9czWBpO_tLhI zri0U8?}D>$=KiHyVD&hHN((}`VRHdf>LaYFGaPl)CrSU~kJoVJJ&td5U`NjPa zrP8Fzr0R&!p2D7@nRxkyNdIVL5Sw5nbQT-gB}yzcY{O zhE)oe6^uE*+2rIYhLeCz4BI-BJgB>!e96GKK(iq^KL+b$7{k$*UMbkkHQel=Lok4wM&k zpye6hw5&#{9i3iTvWhb^&^ym4o@BHi>+G>P6_s*&Ev!>>twct!+kkpwR)1Cn>=>H8 zXAA$c{?o&xWs{KLS1F!CaqEr5tA%4PlcG?6l#8ZYlh&*?dU>Qx-NYXzaHtbk_4Q`!FlUu%G5Y2&aZqQ)3@-0esh$gLJw2J}N#qQ@4Er zX1TU?#q^Gt9Fpe20UY70K}W&|t6fj7REAFr+YkSbrn_vbs*BbDyr~UrIwYkVq(Qp7 zk?!tRLg_|QLXd8d?(P)n4(aahhO>CjIqUwwAK-#H*Baw_I^^)%iCK2?=Luw5P9p)x zpDUVZ+~a7nfn@cL4IgUc9F(-j=cUtKpYQR!bgn7~!p(|v`vk?f8qB2z2(BH)kLt@6 zSuSGxA(JRhK5O^>yYSuXLa48w@6i6~x;t*SC6L_@Y|;G83<_Gs^pU$mxv<@y8?1m^ zr|D4&$&7@Nvx!*9sTX!~eZ#NL%uMm7T}k`DK;yHvZO@@w97-4Iy_j(*Ok64^Sv}aW zI!s%t*?>-c{}$-4B1ZCWS`97}-e9eDm7~2KvmXdb#b(J4(f^4Zk=>vx=gwGhrX45VQ9f8PJR@h~B8I)$bHSf!3-05W^+h3Z;!WmmnK&+30g z+H4Q>RZj`5>g(obEp)T@%YV0|oCG|y9p09&60&*WwCQiep4iApk%|>2~9t!?pTj(=7_-t&PSSb{8+h@?j3(uLB=M*jen1GH#=K{R`yg zj$aoKRr)sa=kkYL(EeSFQk~w1qLaP%6;x9IF6mNWToiM|IbD&830tcmT4WDd8_s*I>i>v>C?Q{MKO&$pPjokDg|oXOa`QJ_;`vJ8bJKmrT>ofVl@`T(ST4QqRbr)OhF|2$tmIhbl=7 zkHDuq;3?~?YhM4FSMs1(r~DfObrIcfB!soE1pOAfu>zC#v)q2X;M!Ur5h|$lEJjnL zBhPSBh*UNv5gF#iQQ5Jmp)}oSq-sa24rQ|i2YSsA$|F1@rvl`yM>6O6>aET9oaQr% z6(d0IDXyr>{jzkv`-9|r=@kH3x>ex(rgxF-c(zt|%7OKIaCvQI2Y};iU>f)(I?I^< z@d^Zdp=RlL86kdqA}oZc^vRyW%ht#g+u+i&NSkFp4*Ck`v0}C3~sE9H?mOgO_>)=>0&Hw`3}z zENmioU?|c06q(*sgxn1Svkd`QR_!BbAi>2@7!Nfu!c3}81oX>ntJ5(`*}_+BSlJT_ znD5-}hmsP`3o1r6`NGSY!IWRJN6!m&rR}X@in_s~g{FnJ=WMZ=4)!P|F7fKrZOz|J zg872U_Q@SrW-298{so(xDE)_`XAs+p0VH_(Vcg0*Hz6ujSX)M0rZB*me!J%f2A`ze zE79n7#?S~aWI{K$fp<>SNZd$#&0ZN8znSTg{+I!G80y-~3tg=BuEb=@D3P4?0ue~= z>_mg!DjXAzQlprWHX$ac`sWCP-P=mq$DVPX^&Pm)(w@NrY4@?M^5II7z(BM^+^s}3 zm$euXa_0?Ich)_M^;Us!u;9A~H7~e>^758u0|~1;&7KYdK@`rG*&`j>cX=JjFBTrG z@v{tNnl@s2#(BoQXm7W;a@a$vLn>Q5E%s9U*{IO_Yf|OJk|A}|UYA>5R%4AGaY%^= zVfeLMrPr^qV*A3OW%=e=Z=>L{$~p<3aveG>MNR_{#Wl}l0ci#m z6FK7mJcMp~l>#{nf$ZXy572O=ii$H0A3Tn5#~oVQI_LiP8YhXmd!C~@h73#zDZy(hTbHBzD1m#z{ zjcm2KJfjR~+nT!h1w=)xf-p~_M!qE?GxGgHL;nX2Z`)OPMV&$M0V+k~p`0jYh7&Zd~&NI_vx4x`WU-6p@oB1?Fxb`SFw>Or*!_ zt1LUIl@(->fSf1`y8G$C5md|wPMUYjW6MnG^Y|W{F)iNO5E8IBbo?hbgq2S}@8m=& zi+K;p0kYR}z3jmqN9>7krP!ugK$Z=k9^(}FJ!g>qYZ(5G@o`*K=AI(JbH#BRwG#QUB1yAEWt(_1#f)E19Cm`Q{`%ID+Hdn^lI z;_ob(K4M^0u-|Wts%h<%skEJ5cr4SWU%DIb zF~?o;8)2hw0B*A+=mN!MUf09vVCUS?C|)kem*_3x0RiYHm@n{KsD9lO!MR9MVj}ke z7jWCzR$nHzat3~{&nY+NJISr%(CX_n*SgRJbs+iTzMxJM)Jc~42U#OdVg4406B@|e z`riA9b*j`#0__O{AY)+#U_cAJ>HInffE+!(iJbRE)FLYTp&?btu$XW>*vntaPgg5g zq;&9;I&v45dyWU-&pwL38yRSI32+WIz- z9wIaK>3fR2k1^nB`{H3<$lbB=6n>fg<#F(sq2W7yM9GKpYP{l%5|8o&p28c8Ir85Cw6`kk}GS&9&etO8+~k-qY6oc)}Y=BBo&d3_3yO4 z^n!~O(NwKLn~Q_0@KL`pUEv&FfaxT@DQwEBojg!bhMy5pm*D4{ajDeNEjvyyS~gwI z^+*<3iCFU;eNB6H4Rwfih;E1aQ-R%~qDEBx(b8V<5;pAvkM@@hj;$w#UBh|7(9x*T zsM)~01DTnh7uieWU&Mw`LLxiZUlcPbdUtyH=QEE8k%b%QSxPcE0z+&NHZ2g@oD|uS z2Twxtd&!JgBbJ-Ux7B3xylfzBm8*=m5vG%`jb$uM|NczhyZW2O zT@yQTwWP{`N(yFFc{)92OYFv@_y10d7~$0X3(G?!VfzJ(5ldPevg7S0FW@eD!x>!l zg$};B%%%h^BaK7o&o+4V316>-Ul~{^D50v1G%x=Mb6cZw8fyt^vd@C1&q^U2ctsCt zdW9=wDvnrTT&>6u|3JYc?fd7WI4`h_wjpS?_FkOwyiCFOoUZ$*d13l`Xxp_=&|=La z>dH{hdE#NY3-u!in1VF8AgL|zOcPLKre%100x=E4Dk$F#&i*Q6)U`ptia<84MJ@&Y zI+m2P>q;Bmu$h-UnSnqFYpNq5rB~{ieRl&oHxU3u1Fj@M z-9PC{$2Y%Y((uot8Swhfaq#!+&LIitF!Rv&uPdGT>f^sDi0AZn{s(h9)~$tV#>MKc zhGl?0ZEO2X){B~Nv3`H=rDUas4nr9l5a=KI2c4LRn1~lHI06Y5_bMa@Re}iO8!`?& z$}mB67{D+w`cj=&SvT7S!mdQP0(pFqm%_g|GRt)YA^6sdZZEg zFI(gp6`T-7^uE2u(J z6fJzL`Z(>QJfrTaJ_6!R3^(Dnz2k&6&ytkb3cY@wUPrS-7#cAgU$l8@mN7jBgcC3vsT1N4|2c zE9##s$*5vM)Cf#>UgopGJuYqm7i`4Oad24`(X)LMTus?>3( zkvYZ6*dqI)JN38Azi1}!wxe)6r}2!wH<1^%%wwO#5BuiR3U|WzCQE1{b5BWlMDudy ziQ8H3HOqHg2tDz`v*n6i^aX9tu-UysrPM!)BbqL*J^*TtkhpK?3&^rU!1H+Cwv*@p z)%8)VZS^77d0kz-HnAx04Dli~EP zny9>;AyyxuVHgixE{0!a28)O`ZG8Gj}hGHuGBX7)JLBnP}qb!2nj zpGU6?qLf3;VvJ2q*_Oa*>}f~DHuP1 zzecqD5eUx9bwJ(QBK8$W4;jHdxyoI5=H zt^=+E)R8cmR*%85H-{OSP zLNAhZ6I0qfhw0H8FOnFE{nqq}FME;HS|f8~!eCVmNkI zt-TCACq6RM?x~NLWZ}l6FcIo~#H;2qbL?LMA=+ZiQkMpI%K0ZkGmA|A&Qp*{%^KLF z&P|OB*;xk|huTE~f}S2PPsch)6x9XPuhrDK=Qquwe+sM(=UNgAT+*89$GS?)zH>VH zYcx-abBOm8;Jc12N=ue@7GUhb>NrTe0?nr&6G;#o_zJNS5$jGMK;uk&Z0GEP1d>aRoAISz!>yKmAUhd7pU$Bn^_1 z=mWHqnUk3ZpSMgf-9X|z_?7fM|20`@ zSp`{zYBCB&3dYU%W_RpQ_@1QJ3X>^Yr=1JN$CV8MEz|l3A4FQMgkS_jl*TFK)2ra| zgA$USH?3L~x3n|1IeT-R!}jI6EzX=o^QMpBnkN)|9S>&NJ4H~7O`N1!a@FmXEvNBa z^XJDLScXd&BCi9$hZKhtKA4g@4{$O+N5l}IsMU4t*`7b)6xP|4Ef^)qVkpbd%SZ%G zl$XQ2?aVJD&YI4e(%XUG&u1m>QPHEY`gdr?vw7f~G@a3JH1QHbsX6=-NzgIQd)`Gh zsvnX@?+_W@UmV~W+U@4v)Ww$`2SX*vTSfS&;0*wsMaildHCF_onzN@SblK25?$&g~ zIrLLUQ%ZWZ2ABO5ng@EWD0_+5L%(jXlg}L)^ng;NLb4!11aI^MyHc(USVK=k&rFnA zHQVBAoE+N95mI0m#)&1iQEl#WwyYRR%p&*h>JLbSu+2 zZwXAEhHP2<1GSp(?+5l7PvIU^6h4lB@H7h9u_O$kXqYorOo-fttu)9d$OyD7qYW6K5#WzLd|gktk~%E(E+4qFY`4fw4v1e#RNt z#2SWqA~w+=dnJmU6*L0JSo17k#+EJLsnR3$y1u{lrJg#tvMmX<#5c@LnWwL{jZDk4 ztj&h2kjy5O*U0C@x~3hvKd%-C+Ne%aWrdys{$N$Qs~&7j-A<s{#Wnwc(-kZB7CBD%#jjbk-f2K@|a-;^^&mfBDMq?iLmo?81w(-ZI3py+A zF*7ocBDwHp zV8LxwyP((y8t5ZOuH7!4`Aj-T>bWTNwJYWP=RaBJ$Iq2sj{YKgBA87<15j+zZ zbmqRQkgi3vE9$m^=NXnk3ks~KeR4!nSpNP%k5c2-WAVw-!61x72W-+Pw~&cz8ghN@ z(4>e0BpA6l=&z|Q3I!k_vxSS)Kooa)E>p6#VifwT({~T3f1_@F5#M9j;R7}UH|2o7 z7{~B-x+6RJ;zW_Psm=n#U(aqD2$0ClI&JL9O{#>!95$%($mq?O`Q0l>0rjv~=OZq2FwEBk4?Jfe?C?5#4IAZ=~QLR4*-D0hL zpI$C%QT-~`cOQ9)znd+p9b64DS3YU_GM32Gx z5h^FaoRwZKt64|tv%^hGOs=!bkC3!Mo&;xlvGw?Fx?t6;N^|3(?qA9uYwRrML1s^_ui-t&)S9^k*+b7Fi8T9tltR(1t|_3b4& zm+Ji5a_Y8v9CN3);T$$5qH>>iA+t?ps??VeDWEK(uKW&Lt+{m4Jb@{Y-m*BY=nI&> zqP(^F!lsa|WAKUoGP`>ZlFJYoQoCvWcj`wVFzlV%?!VR!5bW1YYG83B+fo|NOcKJl zs2J-IeDy%MK>@V&tNA9j4XwPhoSgSQ5_BV(B2}US7kcbm8>HlB6zuN1pI4N~*u>gyfAGS479-&E~v zu1nhD;dYHg(zB1N*x_V@YW5s+EvCUoo1xF&QpiBri0IJ$HRi?SA!0v*ELTsmDe}Ga zhfFO&R;+22x_E1Jdt7_mGPu}7ia9BpaH)9jbe8nemVCvzDf6tHLzr9VjuZH;*n-)V z+rQtXx0Fa_BPk?3zJb*;233C)mV#5$yzA6IiNT8(`}1A`$_TN>cXjT zy5_DrxUlD-vKUd`Bu+M=E4>{bzYq;nr&6XimU3EQQVM-B{K`kY%VJ1@gM);^enhlS zapjeTq(6-n3Qew$chQQlG?3n0!%}~(Xol`I3UX>u=$P!KW#xszN-nfW;^afROU~2| zM_!Q~5xy0yjGq5HEpWa~WCP$u+ojG-^hW~h4M*e502I+_bw_&LYbq;N@d*`VGLyq zWe#kksyhZ%5;h}#%sCt?CH$J_`(+hQKQE&6v~zj?q!;cj&h)!NV3ajSTs~9||2Q&K z{lP&quX-NIG`x39yFLlG-4`h)KGw%bz+S-KUJUZGK+f}} z*nfH2!NyW_TQK2KtsPTmW$vQ=mspn9-wUE4Ukc3e9ChUz;dz*B5#?`LXTs~ow5|1L z3*8#ZDrx|Pd@MPdUy4EFZ(wO3+m3FlSINGR12)L%66q+@#YV|?(OHYankANV9Ks41 z=Ua}KZybJ7e?__Td;kQrO{`cs26d+TbHO-@b|)elQhx}#lHE_3v=vrq$#auACaY30 z$rmRvW)C^&1&#bXJ z$}|V3!Z9mo$Nh3CJ}FE)Lw=GQIWPA23cQN+Cx|g+;{|If2uZF3s??lu9xP4ZmzRDY z6qfx<#<&L#){jouFHNPU{3&Zi{WQ*kI#_~Se~S;w=^8$EIiPw8p!*W|{6Ms_u5fwEu;a?}`eOgKfW+CKhgA;C*QHq59(y~I41O9}bqFX$ z;`}EcCt!UnkTtf)e#8>hm3nd6FS7AZ4&CoUa=gri!4)YE(g^zZSCEM9anFv@Zr%94 z^}tWMjxTl9SA;-h1y(>Zx{D?f?)1F))Qm}_jjW2A?(KyyJ z*0L`Ntz|YlXD=P7g%ZpC9#aO&HAp*8b1-k^80A6Hn}!fW(wNC9ZS&zXRJ%JYt82#! zC=F^H*uLqO@ZH^eFDDN7js(?gVeV-}58B zr~@*n6HXDs3Y1F8EvDS`YlM~PdlM~sPo8I3QJQh4Y1U}b3*Lw4D-}2n@G$h3Y z+Q*@8BePa*^NBo{y=d@>wB@dR!otWpVRat85ygYL3`^cECMXUm_Lt@x!g9Q8lkB-X zVjWAh>?4F}eK>q+7Gen^Lnb>Z+k*lV`)xnJKfUKLrl>kS6o%*RP3~%b8<8cC3{YPi zb=_@t_Wu-V63_Bc%`Gi^Uj{9(sB7AYexvIb$~yHM<$q0;&c>F~{W1WkLytE-(=8-y z&g_6}J&UH{FUjLZYJs0nB>mZY@i&nD_rxZ?=b(u+ssga$_0+$p52!0o7Z<93V(3>I z1Ox<7z)3-V2*=W^NI+z76HXYGac`aI`Lx}tk0^r(f&n7hCIIpvVq^h44|MW@*ez)` z?ssVrML3g4vO}Ubl?4l`$3-FY4}y2akAOhm9DqrhRpOasHzA^<@Z><=PZ=6Ap0xLh zsA96I@gM2zNprtSo<^>`^`tvU>eFhr>0N)BA}_n(_vvp0fWKeGe5@D!0-H_YD>=P^p_#@q!XH+Ow#Q+DsII^vE16oj-g-pVP7e2{S)@>aPXc`iqGNJ;HOR9-DQorX3;Z--2~ za4r{z1f_m}D`}WXO+^VTA$%)Z@nTRBEXld|rV)8pMD7YZO?ZG(Cy%E^uX$rRgEuYB z8TUgv1xS^~>l^=f^c^kf@{p+~tsS~5tr4zDXWtA=86Bv;LhpzI3q*QFZHGdG$IYAN zA49djf0Nf!*PKyL&nnf>E~~zA@)|kkqzQ0ZyMbvqC4p%Bmv(CZ4RUNneo1_0epK?i zE(ee~G2c!O@_)5w@(^s>9WoV8VSxd@zKFCLfpyXRoGSp#tVNEKax%|K);&K34vyX=3ajsP6kde9Jy8hOb^vI z<_cUQkyM%X2w)#d-X0DZ-vF3|B1gYb9rV`s()XH6^LD7nEmn17yKk}Ccof0U^**|W z(I74Ln5c^S?6t4r)CT2rR=+7e9}I-T%R0m4T}#OOSPrcYsfPB7P!xT4jSVPb-_Rdd zK{W}-00*G~_elOPJ97fr~cmr>^uw&|GmDY^|;`|C5p(T5m% zJB1k3^aXVOLnpA8R8x}rhMB_RIm6x3JSett6hx`oWn*2Z7D87LCwvV2ZTe`0+cNE< z+)%VQy=%dyftnnoBuSaj2P5_jT^xOo`?3G;Fw75Uy%`aC%?_^BIh-pm0YjniybD(; zQ1Q=hGm5U##qf}GH_YU{_H)!0E2Rwkvdx%#GahvYM2^F)&rCNJ zQi!(%@5X9&Rh(@q&Oas&swEe*k;fK?efw61Wwfjys?uQ)&?|)XDxU-$)`Rt(CL{1H zYMqe6bZyDc8D?}DbgzHeg0qCWy~23w&G|1RECDZTr(4jJLD-Xa)(!# zIj!V{c4Pcl`COTF*1Q{>o$Cm9Tk1K>LtSAg1cz*v^?->tsC*rwy^3pQlr={hIaBHW z%7)&j7ds!FI4Iah+k3=G()i2vT1;4izPQDo;{62Hh)=S)U)utZ-@B)2My|-a_dZ=r zI!OUoScWtshJGJnw|HK%yQvvnlUy$JgxfQ`VlE$(e$okWC?!1fjKMD0#XwxNTC>jB zap=k0`#`8s;|u#{pvTnl-Hzf}&=hhv zy2HOm_86k>#{%0CBN<*H!CRc^Z)L*4`hXmd!bqrd!xF!w|K;mvcZ6A_S%zcqx)nFU z3S(!vC#vi!y?4o$9P6k0L(wcZ0MuRkh4;26j3|v5&5%#PM)n`EvRFykHnb}bX6R#={N2F)|m*^dNgxm<5`D)!~w@U5vF*K z==II}&C({_tKLh~lk@rWpRYBi7ONvMPP*Ophz%k-r?o5AZDiNs(+nyVep`oe6>{yU zaVa#MN;ar6?r&mZQUEr2n>8EA6LD2krgD9v2G^|z?lWW!at?`0Ov-mM>omcc!uv~; zP5I7In!`G@shS@v?1+N|A>P;z2m$k5M@ApxB?igOG5$-_zvzrrD%RAzDJSq&l6Sw#bNyfkhy9fR8N~Lm)Gi9H>uEO zY75qQQOEPCp2#<`ulX*%*1sO#v4vSk0m1y}9zs_>d)~AHnjYm>@8cbqmi3zP!$;qx zGw{MwNy+{A^*(s=IsZ}aR?JEQ0B0qqyFl*Xv)XH8!WqWi@cg!w@+#~ld`?hto&uFI zhqNjFDzUUUqKj*gk|`tdBOR#+uaBj-#T9v@tu~RHbo)6&Zf-OG@Is~YK|#k#l`*x<%#UNAn|LqxAgwlhAboZu8XJWwdqM!IVEDh+_vZ&!Digi2A}Y2m_l=+v)P-MVD**FZZ~qXL-6p&7YYHuL+&?4Pm-l^|==SK8gCbSOkq ztUl`ZV9#)YKSG4Y!-94vL#xt|l|zJ@W5hK`xpLVs>F>HCz7YR~^7@jx&pVNCVO;vc zoN6dV!u(XH7|)?6G><&jHJ6_kje`g9Tee6n%JwnyVjoi z>jhVv6}-SO2;VH@ZOaI130oGohrcd*P-7I0r?2a3TLKW2wrdz39(7#O1l)H$ttoQX z-jDADo_5~YESA{6BK#QR7TmnELpZENMT2__Gk;Z6{o24)6xV`W<6zl38Zl$J;*%i? zp+h*Ei^ZFohAA(zV^|yv=}it}$FdY%c&NR$J|uIOzew6*HL9qaTd?gaThnl2K>vw7 z74oq*mN(pA`rumbDf<7HvdiTZsM;WX5s#cdKfS$3X|tzI>F5K3OIY8a?-KyRr4uK+ zctLbJ{Z}8r2_^C4!I&5P!QfPWqKMZziNZ07siIO(4&}mSD0%u%B7d3dzLKt){b4| z#F(IhLHO(3^0n0(8S!Mk(IC;D;@4#u)_lVsd5dXqandT!etKVK;O-MiVndp#y1(tg z9mu+xe>j#Tiwjdgps>o7{{ak(V`saDB>_{YG3Gi5{AWJaW_^dz12u&;7k9^n%I8!f<7F&-G032GO%H;OYBqi ze~NfRdM3RV+es0V_6ACZgvL9KgAj9(re4Vox=2jrd)^9sk(5ew-u3sqY#FhiDFLta zuj>AeD5RL^padjn^aD*~&K7=5#j{ctv_`CH;2(P%XsHvWSUQ7ZrjMl%CyWMkOJ>c! zE8p`EN5;J5yYw@?Uq%*9j5%oZ8QQCg1WLn^9W^fg3)-RL)Dj>v zUjG+iUtvKLjrmTNrw1}(?K+J8Q9+o-_8-`z1sMCS37S;&pTZhldRkh&IpmWH`Ny6dCeL3alTvI+&n(x* zg7`W!?8oX;#p*|A=kF^wkABqf6^kBJP8%2HX8j4kLDGp298OMVXV`g#U;OsA)CVrT zoOM48rIWYx^Bxp5zy67i>Pgkext!vl48pq=bb57q9T&Oetr_-^fq84E^$lR*lp@^^ z4r6ntd3R;|!1A|@d-keh&`OVywWw>qOZF&0z`6~JWIMM() zfeEb8XO)ute@gYq|5ORW))^i*^!Z;`0_x@a)!$XlY9E#|%R>nvrMZvt7a(-E^tAK@ zX3^?lGd&Sspl%WM-($;C$IH`Nql`jZ`cGlYK>0{-?8%iw11W;lDx}AQwG30d0h}W# z7ExT0L_^=&6)->vFKee;r`UIhUIKtI;Vg-)VBb1pd0!@Z+mZ-vH6fA7wY)AFL$Tmi zi2FO!d1QVdL%Y!Qd7+D^v#OjM>;)mP1=8l^J>%T9QO(bzjQc#Ei+a{bvhk zL-<&qJS@j00m;T)_igu-_v;8!!nflBE@&Hm0k=!;e*S-xt|qM=*T4>;Xd5P=pxY-8 z82*Zh^CV*hYgyF|P#+oUX9O3LWvN>z%iNlYc`Lux-L9rZ0O8X8iPu-bpbivY!WW#J z%QwQOQ;%1IP8o0f&iVk7v`D|;h62!AdA>QHSx6tH{^P1*h6TSpeItJbI+@%>E&{gT zvO$53 z#D#pfKgqHOWY;ks{Vc%+{%xy35iq~OYV#@@Y(#<> zMu^D;8xnZxv3lM9f?h@8rqy-tx;v+T2l)XP4HrG?m#h23frnQHoXq1*+6=gWr|gJ( zlKq08H>#ALnF1<`QY9>?59xIaJI1Ww0IGol*r)Li1mU{I0yE)hM0{SKUhds5Jh)NX zIRReMtu*Huy#z5X?vvXC-#a^&I+kv!y7?Kw9j*Q-fGuIlNqe#g&fFS=RK%@V4uc- z>gT4tZd))vD7P~f{rpdwWhl@?sjVP{Fjzvc@T9oq+V5M`{`)MRk(sG4hu6IGbJI9R z47xK`&OVHB*ZIFvo9omJ(0DA;lRTKfMHDJ{~HM_k(Qfkmd-0QP4=5ID?>8cq z3!~k7$Nm3y6|H{OhZyP0)>VkUD<(xbDCsrvPhU{9FZd|#6ZwR9Kau1wM5difU8+{3d`LHX}eL&)~fP(o={sE0PA$dUK;16=f9D%mpw_ z2b(3yC`jBl6TmG@pjwW2{tCmMobopbzgDyMN{X=Bor9ovVrSdc^iFTiky}i@i}|*< z96Egnr^>xd6_q>+YLjuC{JVX*6wQKAPfFdQ9^3s$Nq)XWMaV{oE^OitvU)F0Tel4x zGl?|<`-g3~TFuyEubqu&LY3-zw4G?W=0N)vK|B?Z>AzME(5ChIeU}_(j?P2GL*xS$ zE4hL=fD%VYsUFyCi0LacEUMyA?B6o5y!G+}JABU1pcqI**y+?qjWm6~8CrnMWXUrW zro_^AMXX9nuh}$6<%aHV?OPT0^rcRZkqc!C4(p>b>J_qpSTtu`_F?4oZdS`vraT`4-bV6D=Ox`4?njLOQWAkZiLeyWaUwlVl}#m zZ#08hn*<$eUn`I*g?V~&3nQ|JZzU+d8j=S)S}HRah@BCJOu*?LKw*d#DKv zKCdlpENuv)bkzYKvkDDAb!?20ar1KX{*zbnU1~sH1BRs|F1OstLB&8H(?U{TV@Rx@ zE5%2;xr(Por5Ym=bv1AM>TOxe}QssN(%(H3rO*Z(oC; zj5G)aG!bDHVHNLIMUzzd*6jx8=IZ`HLO~K#Kv;wmq60V)z8(B8sM4WnZOQC%O6!qK;a+EZART--Ai74jRN@}##~Kh zqWs)r8?SS<&jDLCe*$@a%`tAShXKNnHjUQ|PSmY`k9)($%2MKG9kO(P!wcw5^JVnI zIE6CBmn%2^!6YjG?K|nduTo0eUg1KW z<6TE_aSII^GCnp7h+aflSPfPL;|~Z^qW4427Nv-?2)0B(06Cb&j~tBsPE8maPVLJm z&v!C~J*~RgN8_@T4A1hR+lAB1*4s9Ky5SC2wr6um$t>^KCVw}a@;h}2hq+z-m!O-g z1EkjBq1KRJ7th8ga~XT!8qo3b6(38O46>M~;EUO)s`_Ok;@(-dScii_#t>^@FN?*o1)H>V1s>=9m~-+OZq5CcuIK659S8X zGtxWrrf}E>!Cw`S{fDV=YX*k~hbN#W$?{lV z|Hq8SjF#b2)lC$TI}&furh09>lSUQTgxPc6mLOo}DR*n^Rfo;&H>L9*-?Xu%3o7k) zp4NG(UWyHja|GT$U#epX43#icC4p?`nE{jCu2-S2PVir`TgJSNj?lkzi+>8w@E#Vl zAd&n1RD@y^xZrnFZ*4a_#!dCwkVaKf4AlKltHGq-R zV$<=G+gknS#YTHlL1qBjhTNM@{oQisIsZ~phJMJv!zUm%SY20H3@Ae9K;-6$NRt@N z$wTZwW4T|kaLEU9F4GGMsG-`)qvs5+ax|-4+vpUm2ZcOT5=v8FbLVo$DEa@;DSnEt z)^ibfh`afnQ)DHJ5mT&Kh;<-d^?J(H=QEfEWhbHkNt1&u8p+>7QJ^4W;#G=h@-`U{ zIVXD0bOz2cjh*R?nmdy>6RaqfB?2JV5-TN}rA>EZWXOSv`+hAv<^vY^*7WXT5}?@S zzW{G@T7t+2fAqfck~EFq`C@oLGG;GjFNGV;8h#4(w>M6P|3q0_a;7*`#b)@O! z>EyK$HRMY2gN=D_$JYs}>*tknnjNzs1X)iLEJHfhzso!jMq1l@kR>yw4!P@%X9dtA zEjV&f{H}jm46=)}*Y|R;qn99%%b6jXCvB$=A7=RdN*QH+lq0Gs*SDUf%RVIi1*JP* z{CodFx-}H_5f8HQ`Ml8zVpB>`(ua>|h-Z)Z8NV`!>Y%Y`jv(pQxxdtxZ}|FiAIk-a zID^cJ7`v?V$jcQ^p=>cG(s)KkQdiHS#XdMY2+S46Y)0p6eQ zLdGMqamB{0qcwP_wKd-*-}(;!^+K*K5ICkIu)=oNh_dA0{CSwq{ty2MIV4gNKZ=b& z#Dhg3iC8|w`Cr+Qh8x2ffd@)k$bgS{Tgls~0&MGZt$q#jlO@qBxbnsOX^dNztztOj z_;0T>@L!cdGV0@b?h4TxnFDtd3&3wyI7X!Z@f}Uw;xv-bLYFn%cGObpBcgorxJ+IZgftM5j9&#a45TU&#S8f~ z1U87guJk0wJPDu~c}`W7@r7-O6?^xHmGdc^PBr<-EC^a1S!`2*!$?yWM)o~C+kl$+ z#P5WhgNO)}J|io$w3Qe$$eI=($y*#&a7 zA_1t zQ^Zq5$3&TJ+c0pehVWC^S4O0iO?r4D$G1jtuc*1jLAN;A`m`zFdyMhuUENroZrh#Vmz z$dH+kE5H7pvuej#r2T{8FXq&MW1g6dt33GXd^X`_B%@e&;y!{} zi9%}#jU=e~dVPMQsu*BeP?6#DSBR-h3(TP~4pFhLJh@T_A!nS-#XLf2Yvw_>ZC*zx zO${v#tx8$pi^A04J8|fMh1`HrVNgy+Ag7Ig6t=&5#ZN z3YN-L6@kD;7kq+G-GBMs-1R;Vl9FHAZ~wFK`1n)hQ}KpycrZn-q!&{_0tGZ)JvWf)zb>Mo7-^qVan_6-NTzPU{+ z2M($JBti5$e8Sg9O9GpJAK(b1t^$+gE1@2mymfq$Dom*1$j@aqQiKFF_bQy`sXlW( zubkIc8t#envMebPJ8JJXjCv3guvm4J#2KKizQl~QxJA1~FQ8Rm&ci=tWCceMfbJ_G z)v?PXlD>8b5DWlyxJ|3Js41GGdO>^1(#PjkEmuK~y?W&3C zl0P4cu+`qX$%ZF=3 zXhaymUbJ4c*20nbx;!7=AI07?TxfLQ_W4G?5WJ~^YmBVPU6}!JpSyXxd82!nO;hUh zVpmPw7LhULFy~eYHkht)+MLL>sR8H+5;#$e?x2&!7N|htAmSi}ApX@XTR+GP#0$h) z^jJ5YH5=S65P7gr;CqNlCkm7XOqKl)T$N9&CAO-O$dnH?W=ooK(PGCOgKG($w7g#o zCiI~y7%CVT5fQ3bTDmr@!g(ENo3J}daFdvjgPuH$#qE{BbA8$SlRwnok6FubmlCYu zr6w>0cjkZ5OOwmSn)KZ79t+fLL&J3?PQsxKt7Ki~=&Jzb)uTQaA4`hghcx1&a7hQx zvnSxHqH!(aRHxi2zH{b9Tl^N3{NgR4ite~R> zU2+ArwNfIzg`PP8uGi@unl>%~uJ_;_S{XI~HURw{S_hrG$~lcaP$f)cPvQuG@~Y!s z%tCUF07BdRecIn$3^S-PCY{SW6t}2w^-HI|xT1)c_KTA<((XukV00|$+f;M5IB=cz z_rAP?#89BglI4T{o{b?$?K@54cX5N}WNbScqPYyv3I8u_M>cJ0#L_V>BUE0eK7K95 zRlGepT0Y@>uTJa0#9Xrtz*w)QPRhsJ~T#EzX{Ap39TTimq-2Y zY=1+HupeEMp$UG^?z6Yo=B+&W!fuHDj2^fQunPq4tXD$J@C1qj%&d_M3W^FsT~nRc zM}*W9u{*`>Z-eSdGf0u)+KG-G4H=KK8~x^A?>1V1qHg^UAzA(Svx4!Es4@I> zFhb63VIeb<8ZsNLnfz!5OaSEs#D2~4!_VAhO!Z(lt#Lj4S@8?&UHWFz;2_uB?4Z=&##` z?w;;mhiF`Jj^B2_(^f0%-*%U?`A*)A`--jlAASfAl$T$&yJ5bE0tkim%B$3FMtPoy zJng-Eki2zbiTt1LPJl0OV=Tyx|9;yDEWPn-be5P-l4F~gY;=}5Kf1Kc{!_N zEGH@|ePEwS;8Bv6k*NS_i{$d8hL&S2F;HtLSgAJUY8wPI^GWAZyTZ9_RhdEAorA6> z5w{?&O|0qL3_Z|^f4_pXd2VvEp35hM=QM6oA%J1MHsaZ*Lmz6{t*&KBecx&1%q1(D zFY9;-kKYtK)$CfaO`H~WeNZmhJW@MgP2d)VeW0u&((;HJhD_*rkZX$sNTa@ho0n1- z^l-<%SwU17hDATueJQY%9#O$F?b zCE^Yv!rL$Lo@D;$zsg7cJ94sfYu6w7@x!h7JHt*B0E{|Ad6Em^U+a^`TkV+-bJCu^ zld0p*9Lm|#WM{E%gYClOvEc3Yjp&PhcNTvlhJj&R;oCSLlWe1q8`L$_H8->sj1>%B zTiMtT|>_aapZJ# zW#NGiK`zjchM$7eG@Ku|7jj6{V#@T$28JBU*u!c6BpfE1Ee$CMqr{2EKJx6cFD01f zXNA|V>4s$oYEr9zSD2#9z>tgXLa3;mS3kS=`HR;uU$p$e6LyJ|+(nl!iCHe>*k#&5f3}60gsEcjEFI{*k+>)=yBQMb8Z}4d zK`sGL#`qqVv@*M;K2c%Y{PKw_YAY|k@u33wmoU;hC73n1Ba-ob;``*tuuVL~8{dtB zAjtUq=@QNTD+?nr+Kw1EDrv^j^IaULUg@HZg_S|53+#CM3 z+r(Lx2FhjGuG(0;T5LX7eArNFT`DOMo3&yR+-TF(FyLrNm4WLr(`uEQV?C=iuj%A|$L12)*@BEGECQ*qs_hjOF2RaX!SeziWM3 z`Ltam*}jzi+8 zZ1hTrJRd>dg^d&)UliZ}!(ypwzGh{=uYCfa2lOaI80|bT!imR&fTne2hoVLA#yiOP%<5q3l*0Jg{%R&bH0|+X`IT^U;w(;Ttwn$u1AwP|wW_ zjEsH^_1idH)9VK6t7KL;#X%Wr?8AbMzysFLmwO&(&(jo(AupGP*4wb0HD$XYyBi2` zKA2mFC-l3 z&zzWKC-qJ8tWHAdR9*TpO?zs?gv+i^C!EnwJeo)0JUakxhM)@&*P9yq-=7_@-#r2w zWHZ5rFd^#T_?9L?u!l5USZ>W^g}z^w&f!QiF*UM#5t^(dJLv4{Eg3T-58ktH&0MF( zPLbscOSnkt#5Yl$Fq%Y-;-y|t7nm2C7p8O zeeEQ1cgiG5e0oZ;`f&^M`~m31N-8va6Evx+4(;J=ni~2@RVUP_UTI2w<>M0z6p3+v zxf70>jAE^VW)+u3PYHa_#kiplxBk<(Nq(XxPP^fI+MES-#B#)vmTJwZgDNmI9Yi=C zAk!kITYBd)H(z0`Wyarul-cF3z2LDaho&a3hCX-GHV1vIaH3FoBN3?I{|T}h;&e+u zJK!4?;SkQya?U=mTWSGC+r@uz^8KO4;lBSLVc74s+oPrGBZy)k$=tJy?Xz(P>-a}W zt++ah9gPU8l}oyZMDH|;a&(-!SkloKT)C>FSI-j$K9ersl7S58ySNd0FiIFev~;o1 zEF}$j$1FKr%a+FEX6!J14!2^Y65#UKwg;~FgRYf1#%PZc^JNv!3V%b}y~=ieChU2< zyAa&^DCM%&i{hHIRbv3fDmsb=mhIKTtk9Zgw8r`Wx?;F|Bp_%%6acahYY|-`-~T%= zIBGI+H`;={{efGg3A$C-Hui|TixZ%j-uuN`==k;TOYKaotLakGDeLcWNpTf_W>GJH z;A^rjqXH%HrsAf89@e>lGTQlfK0Th$E|NVZR~Zy|Xo54LB@(F+IKrW#%b}pp8_uQM zA!py=KmlH(fv-6@jha8qbbW&LKYoE^&??oR#ryS@#ZuBNkln?>Cb>f&G!u< zy4nS@EZN#JT=&~gEzIb?e+~(0>L?vg9Z$0w5o7 ztFhU%(rV$yu>-DR4*%Kb+2=$BxsJ!LD((x=i>jPzri~iuCFT&{+mUA~q1|~qGxfa` z&r0u9Mb5107u>x&5ij{4vRoMc@&bjKk|*L{?>M99Dsz0*y30HbfwIl={?K?|JTX`$ z;S5+M(OEP#;b`^zxni^tq0z`sncr%*Q)p2_kSIeR+s zSqiA<5L|iu`#iabFVkrl%%|+KDR5K%w>)Sm5i)aj``=gG*}+p>beTbB6^zqD>^cEq z?vgfeN^+_yIVwj$9z4f#X6LA-Q9t*M16oXDN^Ru_CyU>>y9pC` zG|P0!TGkfEF0=VZiVHNo!PF5YQv(#i?eZRki7U(q!~nam7w4xreYPO{;ug9 z!nTr!YT*HvIzFU=$1pF{sm-a4zSg<^jlRo>P@Z$1^QN}_K>Jo_b;CnVd5_nU*HZgv zL3S3zdt0H~M|ThXtUKtIu+`tTcCifG2-WcJa~)RtU`bh7S?4{W23-IcOP1+p+8Z*~ zHtsgAE(*}fF28*e)-mppd4&+Qy^As^80Saf_YvzG)88~d(w0=)qGgh4!a^?T>i;)F z=VB$cm#)a|WQ9fn$?k*qNKk6fYS1ZxPW{|lL;*ri0G-(KZTi+FBs?Aw%@8%b8m{H^ z6C1-f%Qwqv&Y-~bN#!-iN8bX13_>s4z;?8i)l*wHo`NPhoAleHI1^-uq~gnM z)3nqvR{MS)lHCHjmv&CR;3VZ;1BC3oO22suT1Z}D27-+(r^Pew3*r=L#~tiSm@V zkpP#xO+N9}-*})k2Q&_Ao8EwmC+VECf;QB8%LAXtobC446v6gOpKUVW8Z6s6h$@}{ zAhf@De=YQ&Zl3^r=S3bf9k#J=wy*6Tgd67rVS)k;aJSAYGY$#_M4kteGGSRE?`;Z9 zB{1?u2?y7qQF8d{Y(GQ~C<|i}f26i5AQV(e=_E9vh!nm{5Gp)_OlhHT5YH=;no30T zAiESQ;L`o<`|lo>%uVmKZKcxw+ej_bfZ6ZTs^YdRPl9nSf%W_6g!jo(caKY20JL63&Zj z<3REY0}p>aK}}rru;l$5li8>HT9RupIJ8>W*W>Ov3s z+^7rnm`}3Z&stPSr=Oz4Gq^ze@NWRoZ^b28;1}5_^R#*2Pj1086hA)b!Q$P%`SrLPx^-5HXvA@ zxJr7uev#Jjer+tQkKEyddy<9+cE_#0*96y?AoKy{%$K5=;OTnl33`4+dZG&ZnqR_$ zhY54E<*4D+eHxn#dR#4Ay@wVq4LmqH#V^;rK){f1?ahwh!#$V(&DoY;zY@hsUraeO z{opQJ^GCH3d~sO)O=kdm@H%`qrZ3zt>~}pU|8DKQ6xjo?c>7Qs&^nduMAJ)}L|MWS z*+0d%AR`px$TJZkJS^-Oq!=J5|0p7oOSPo(w~+;ktkddVqQ5Gu!OZD5YS@g4T;VU( z|6>H6u3Ob5TMgOd;FSNFR|UfZhp}xHRrAo~BJ|iTY2`bNHf;=yIncy?loqA_Y>1b# z>>N)xlv7rahd+6W_^wU9;VvcKiaPT>8s~JWtUGjTS!6FDK_@|9qCbQaKpz4njK`J* zCYX~&^VY~YIFQwG3zG74$PrP5rIR*o{w{(rcHf)(p71;5)@T-SOlTLSvOq3-)l+c?Bx}CY5nHSb0J7;wt>oB|Y zPj>Z04Q%ewAsg_2*7iN|F@k9LG}u*F{fO}10?m!lXTAw;h3qh0W2-J@Rz2n*gBuRG zG>vT@)S0EPd0Kp_aO<(P;%fB5_qXEGoB-OoRf>8e^SOpgAU_B~J17#Vnnn%G>6u+N z3CkG$q1*WIrSC}y*(#jd!t%7aKff4V8^eo8FJ}cYW4pitVLLWoUrYu`e>R&XNeZen zA$638-S~A(m$s|epY%R})1qiZgX~8{{-%FwLpFQQFfv*x zPAN_;+4`8^}?H9KZBn~&%u<2;se;k8hla7B5ENP%K+Y%-Er&Fj$Qc=%exwh0 zzoLIdBM5}qciMNJJA7o+(5$Lq7wd}f#!f}8T{dnW;N5pF&_u)F03?ykbIfzBp={dq zuSZ3*(yTI&H?cLb`4Vl`Z`E&+roUK5OQ{hchryAOc)L?2GHEpFwq7b)niZyER|iKF z(kGYw1evBJ>M6Uz7bGgsWh?6!2P}%lKe>2+0l;Cgvsma)>O#+3eJ%j5x#J!oV2)sq zU|HboVz~whQE;oe?O#Hg%wpM5jh+C;Prh$I%QL5nW({&?3ORFAmCUE2rGu#ykJs&9eKaw8F8zQTueI(o8R=hLn+#oS z%70O(kOp|9=xWRI%1Sn;(SP47y`Ry{uW;>1g$i943%(>w^O0I8jj4j?qNof{WfY%7 zN8zG4Yro6w+Xq;Gyu4QVFCrYwrD`4T|KrUMSxBvKkRyIS?`;cOu?uTDW%gmOlwhtT z)XaH3jSp44dcj~l3Z6$sYgm~*!InV0boTWrme};mVw_3Yjol{KMLHzVpKQ{zMq`WF zOdTLrwQE%c(%<6Hhjxf=kG#P^x}+UT-(|3#$%4oT8`{=lntJoC`zz7D5+R4Q_|g5_F0Xhp;z+-%NeGwPZvx zBhbP@c>ytGv(&THg#<8OAg|EP4I-x>+%dVo!9@06t(_~}vD1Que#4@%jyl6Obff_p zRJ21{_K$yNSa!RhpH%LOPgh~QNLH`*v%>xjVt=Xn>Sx?g5%sFRqk- zS}l;y3aoQW>MTDdj(u?7-AY9b@);K}&z50>%H)(MEJk);?mSs@P0-eZ{&6d~^k(7r z`Qc>9PT>`%)yZ*h+ZP45N%ybgSHf)|=GW;p46T*J(YgS?57Z9`;`&ASFFI6nU31+6 zHhf$Bl49rIx3~J2iR-|g`=0v^3?CAxEpm68^Ccmf53(q-C{c3|`i5{Y8X$nb%4+H9 z3PeDZkVFkE3@$7#EROJg;iL@R44IASQm87TGFPFk^b7K|txP-93uA$A@}t%vk0fCt z=SLgpg3g3n`K7y997)82#aMOfO6f;w$#$NT!&w%xEye!aQ9|;qi6}wvG)l5wIv&)CI}OqC3txl#G>I> zPP0`}GC|%GIYE%SMu!Z8iruUTv|tyMDKI2{jyrRvTX4kgNdU1=&#y>rb{a`X=44tm z$_0J<8*LpM02y%lZogq$YiOBbVaUai`0wSfWZb3>i1d_i`gI=gVpi{j`dRS1O`f5~ zJPxHl$NJ1)seLd0FmARksrfK+z9l} zm6MGk8iUL!dd%%ann{(z>ZbODtZFWN&mK9Ex7R5~xc#ruGuf^9Jz!H~X3{-!*MeHb&NjG@^8wP(|bZo?4w1^Y{ui|HzgH zIoS%RwXCpezRO)=H_Y>XNe7qzG$ShYRs_!?EfS99z!S`jk@OgXBEwmoY!LIZ_st<) zQQO0OVn7nd+2m*l!5JPK-e=xtx~Kt80Z!xiS1n7Pb))5Ewpd&d={=S^4UTzcLEVF& zG^@U(yBoxC{?U!$6z;;1rHNsl+>>fYF!eX<;)_IZYt56c{F}=OVBUGa9%*WqZF$!QoO@$T;GK3}_COLnu4XxWFD z|1nVFoL*0e^VKan_|FI)=Mf}AZL@_)&-VTNfs*;Y39UrLtI}qOt^ze zALwY*uAVR7A@ht}Gy2dr1y4Zlnf8@PRVaPl4eGX5p|dQ&mPm2E#O^P&V^u~uP98sh zTH3&>f06fkwC&({(0j?MFIRl+7U=v1d(6JfsKbHt=XFIg+E|pCgt>@tOdts?WOx_8 z4_J8~BF^ssz9FevWp(yRh?2me9TJ0-6~Z)|DrrUQkkKWXhEVu@?2gzBVj0OfVoa72 z|EH*ul~!EJkM;Z4%+hKQF*hb>XybfpF);f%UAOoEj{&MM*M4Z3|4Z0Qm=AR@ z3$g)$ElN5D;9J5HzP}^f2r*+bsnuM$TD5v7RY0Gh7_yS6D%ai?&(#eATG*ejtb`fF z<0$5pblZpi?}r6RT(Cgo;%!-HSq3Od47UD9$``Jdm^^-_G6K6aJqt5^x8L425w~dv zInw?0 zS@Iw*a>9j%4FQvmu(vh<5etQdNdGVDC1@LY@CfRG^6Ja34G4Oh1>`kys7pYF+&g2=iDKbQYk8m#e2erl4o*tLm|J6c72V z1l$1oO8d%lOZ&SvuT`BX*@h;dOR?e(yA}<3_7?gpqRvWXVaujY#7}n-c_80VdvNaT>*Kt~Yj0jgC&7fh7+rm8Na7-nT9jX-z39_o3{R=f}6} zkBf#+Q4DWC2lxcw=Hy&dPUsNK|1p|#M}X8*AR0@kec6h3G8>Ck?Ky%U!yb#*5a{fR zI#L}wSs%JdE2=B2E8#;IU%1;YNKxk5tu1YFYJCSo`x=eKc!R!D1&9j7&)*Vv&K9)&9M?an`he#*8(S-0P4g9 zn?A6$Tkp^gumCU~K39*sHzB_TiC+)SG5(sL)!%8^JKs#reOUm87R-w?Ga)WCHmmy( zr(Aw{*c0#|XG&~jILq@C_mrN@x?1J(?-q$1Pya2f-BHfb9DmdgF>Q`05+RoQ4c z8<&vh(e*sOHTl+NR3unlc(*I~d9AsJLrsijkYE9^?a8|MS*_&WLk-lP5K zQZw7DoKEJXxSKP28LKVO=)DAE%((`a0hbAPGDX%F&TN!l3nR&qq81S6KLK5<^bHG{ z9WxU}J8keph?>4M%d-=GLK(}Jf*Cs{0;fm4scwkxOrXY~-k{#oe+Ectd(N3j2(s=? zJs3p_p1e5*TU0MV)%0r{SF&y(*@Heq-@|PjZgd1)p^OLFjB}c&LqCzOzU{w$A#b*` zU0>-kqysK*A@a);vfRXv5-;i)E~T%3yF_t)jVrc%@0l)?ykyh|mO*iQd}jez(?5!c z<#??`KuaQ}0)>x>htQU-?_xj7V$mQ(O0`8oPYg)0RlVjv4Zr1XtwYRr$Gl~Q`9VJt zwscQDh5TvM9cd&ZhzQLi7cXV8HE*t8#@}4t0+7E7KL_2z#r{os7iE6ibqxS+SJ4y? z==BN%w9DtqI1E=US1t8om20QA+HFZy&@o$nY%9*o- zJ+`)7&303m-VWvRHVM|qpBnLJ5gJAQjP{*@oO#AOwRIG5!e!&=47gNpiI_a%(i`Ec zTVQ|wVQf^Z7EJ`9qocc!612XJuy-U)ktp3vT6)5Umc7B3U?t^s!EnorD;FYtQUq-) zx2ir&*I|2Jl9NK(m2s(M!M-s_)c*`k1 z+ws_ely8ECMxm?&8hakaRW2(Pdb<90{XIlfH!rV$!TAd$8)@AIt}dV2+;NSTOK)`S zbnGO~%$glZpc((sjEe!K(c`w;0=FE@)ZCC0WI@gi1L{F<$B~bM_VK)H#r^^)?!BmOM+B5=Pt6SAf`Wk5PzEEP=YT z3quDI6uUY6E4znS#9A_3hh_97uvP)y7zNZ!XYx*~d=~zb#f|JjeLY>nUBhdTw;-<| zHI!qOTe>F}G|@h^Bf1*fCfg?E-X-G`CDAdL8N&Bo=T2mG>hgF^1eg!uoKsJQX<`065+#QX`YPq*YwvzxFL|-* zUIOXMRTnW_w=sb56l&O!RU_J?a3^TCXt_gC#|Azu_`;N9%x3@fAk~mLiV$#1SyTlm6?^R>|wDwbk7}o zaR#fC3>e<9u)5Ul)&DJ^btyiMa26C}qfDJz zMN7p>#d<)>JIX)GUnaXW1Ok=~!^dLAV&+2aXY6MNxx;t*9rN+gEHN!H^+9p0aja8q zX#BYRxDNyraujlT$Yh)xoE(o7Vte9y;%C8wp#U8;I$}EFA=VeqtnXTO@al-=A?_p< zs1>NkwuVWy!{NHfAD6Lvtc)9Lc>>ht%B)QNZxU}3-DMSODz!KCcJ+4WAa8O!75Nd? zoB*FF9o~pB7O1OabW!(YvRQn(*j2r2HiNK9gCkPZI~q0%6?@AJ)oRFGqz@Bk>BtO{ zs)semS=j-zpC&;+kF1D;T>-cL?s6S8Mb@E2sfzY?y`3R*jjB4ZWS(Bvw|{RGt>j8M z3abLHW2ObA1ySWmixmv(E|fhnfui(TGWLWUiLJ3qrUKu%NAa?d;AAe>Qkr2$x`oYSgk(Pmg?A@mmk&R)bkd6*gCjNXcH>OFwuj zO?uyFg4gq#Rj67PR~9w6JOPgZeYaJtYi@3FCe9Dp^}txpQO{fJ+pD*fkyO!_p`)R< z)`@$D15;CD%$&iI2y>5QT;%#{$oCeUw%?yL!AR$%qQJOF;9T#aVJC8cc7V1psz{}1 zrHVjM;)n_}YGttDjN!~AOilUX-0^gd01(MvD>1!{pj=cSE2RY*w>Nj+@CrYRIg63= zPbgQY65xioHRyV~e7X9nFr1aRI`VHaGEAS(895`<0Z31Miq?8|iPhq&w>3jaL`gzP z!clB;TU;~!B7BRwC}{Eq(Yy9;gYOJr$EQ{u7`T9_&*DxjpUADWD~A91abpTDM&QH1 z7Qi@mnW0(3mc@x%>f<-Xzd1Es`0h3^?LEvj)SAeZq4UUw-PYaK3eZ6FadJ;SUs;iNqN!O(8H`FbYU++(aA?7T;de0X1F?OQ-0*n zzmA#~&ADDJJY!ykbTs0w&0xq;eNf&3I(x5`4)WOqLMNGWbwu=feF0e?WDTL_=%jtH zo%)C_qT@cWK)-IXIIIQp%?3_V=gL5hkU1;tXHAlSs6wtnW`-zlpIc2cny+DK1Q~(R&umU?f;>bJ&jBOC5~h#RiFCXAF4mpmLTnR0-m;vlgm4yl|N7|YW4sA2 zGS6!y(f?P8?)aoB`uY=p+*FwRIOdtZZ(@KGRJFpBzXPU9ZD1#a?_1BE{_XV;o<-mF z=d0wOvIwTPk)BC!TF1|;!kK#DD+kStNg!_*f;mrt%nJb z?W@7PICZo(K4*`8`47$r00|jo5_XI_Rh11tD;k;hh6c%-S=iPHi_p-OqV=#A5j)jO z&yzU{tAhmwFAD|AIwTJEh+D_cKRB)5AWqPoW8}A#1R7r$ORf$(j&1!*9kfOAagKhP zH3Bsb(u8!|@W|dnL@NG1UpsWN;LcpmT)2lN33USS7(of89Ov`s9}3{6Gw&Kpzvghj zn8BIBjS$eN;lNx%KgdJZ$SfCD(iy&w$bLcM=td03HVSdaJketva(8zYmFZE>L45H8 zi9NuU3qE|5(Q=&ZQ8>G_sR5g6~7 zL$`Tdm4QyogA6Ch3$vdp4K9w_o1GzR`VQ2WLNRBhJMmZ#^TRY^`kr;DPb>%?xz5(izcyp zHNn+d;bT{V+9c+`l&D!22*>o5-O7OQsKIlOt>{{aUzxu%f2Rbv6}lCA!&i_3@U$PB zAy4Qy2s?6cuZhqI`#`mj$Beuq<81K@w)=PoPd&UF#OEkNMq&UM@uE@j1I4a`_Vu6l z$Vc6mvKNHrZ{_P~k4M!L5ZBpm{6`Ne>nxW)lS?8bEXZoO{|YVxM7I?IWI(5}*V`%d zxkkSMzF%R`OYTeVDqfZM^YB3RG30^y^hAMyWS8t2<{9QqLf6}zE}G~c#Ul=A-4mE2 z4giVMOVrd?qRX0#+4kj6<+dWw?hdhTL+vJnC#KYPaCekZXMZK zZO6c6nuzdRU>R)Kzh7O5Ps|O$fsu&J%oY$29GBMHTw#Nk0O2j4xg{idtNk z#rpxU_MW3j7jlOKhneZiVk35$@ zHEpja!Q{zEhrFG3u?*E*1YnVpp+@9n)hGG8>*9W}``5q3C6lWWWGxSz1 zU#fDbTKjecE&A$TSCD$Y&I%*_+Cf#bNBS1wp?Y~ojV~i0v<>bkQ%)+Q!mpwx)o^^d zHi$umdDxrDFj!C2$1W35lZ;<9dzEj%JrVaZ4migMZ_2B*kWtdh|53hm`1x)B`>vnC zG;cZ8#)DhbN<2m%1f<9kqOxvaRsLoUsJz#Ttc0X2?9e}X!|!{tSr&9tjkw8?B9S?` zfG_b0lIvW9xETY-Zc#Vr4)j_kggdI;weLaZyV;b#({336Zorn zb!MlldcX;bt)IiPsQq*DRx{BX5rqq-%Woy;e0@yi@uCblI@m>ydTXum%7rP9F1R(VSqBj2 z%{cMmgRT@dp0}U3k-{o$wN~puB0J^u25PN5x*Zpr(YOo2k)&Ps|H=q+r^BTw>4^i` zniE?KWfcb7D35+rq?2oc0q{`K(9zIx$TinIpLa4G<;9`xJM)-8$IWDlbO2!nb>&^c zoSF)GhlXzO!T3VH%G*34MK1wnmh*>W8duDArAycFb>ePbU#<#|Z)3*RBtae;6YZXB zb2T= z1au*_#Jknf93<^{q1J_RR0xC1 z{603lCKhzP;d1|fo9E0SF$3!%fpZITBR%jj3l=yHNSPb?iTMMvIdb{W3DiHIclM`! zt(bfALcSx<$q!7uUW)*&fhL_l>;r3h@355iJ(A7wtx9sa6dQ8AQan>UImmSdbOpSz zwRKc+Q?WS}k->ver3km65 z@;TQN5QSgze9<$71Q>B>}u=k8cKjNU}8FyJcwD&8mL_FJ70*Ck{FS0DB6vvF6K%5mGL zHD$-F3|c=h=H_e8VX0>s`qJ_UN7`-K2GdRQFroyH79@Y%N@P|`7Q~z;hkE5y(ZkM| ziyEn(|ClgXYYpzA&Rr|&3v}F!5FcF@7XMU;xZMU=;5S?MI&8()=n~K-g+ts&_AI$1 z=iXrgl@F(^B)n(V)pSaWpAa8&$07(JfJ8_eGWqW+o2ZoJdeOI^+YnEZRK>ed9Qc9N zE7oel4Lbx+O2PrtCdn?x%t9uSNmaLq;_ul{Rp2`X%-=9bP%)P!_mi^W z5{J%s<@|q}mztMI1AIb!LNX_1nHiwwrL7AIfMjtz<5d_Sqw0^U9@*q<#{>`~%?86J zV^;cuEPcrAQZ6>hgjx%6`xCe964{Jt+hOU9{;ZNBY6;wI&^}h{cutj~Mu`EE5Smc& zU}4T!dzgRYthN=?6hwU+ULG60@lCFwd~Zge2AShKtZmO${a45)Qyo`OT0orStKb>z z8LS;UPn8E5Of{-LX@|hUS3{24G)*}&0WbiwB4A#~I!8Vw0dXoz)ybcl@hkk$P}kYZ zCYQ~>YfP#R6Fbm1N#nyyfS97Qx(=*~PO2C~^FVJ%U8%CCaKK|j1BdT(bJ%Q|% zqXejhv4T*ajnH=R@zEr;?&%>Y!dKozuKA()rJ{eyX^019-qyOg5w*ffo#Tk2W?s{} zVl4EZTT=45wubOVat~9$7Y>zi$4S`ZKf3}fh|i-FR&-JkOg*&pn^JY{{LeN1RsS*&F7N{IQa#cF2uqJKvELTL+!Ke zvn9W5X!v3uY`}K-FCeba*e3Kr$CAjSnj_6-vGop!Shl#E;FtSuM8iLgQc8u>kPvQFMb-$j2KpfSv_ler)(U`JolYQ@|gs7a9= zz8)QBWXyh^V01e0S^KaFbM@=5Axgm-2y!y~Px($Gs6QET3Jz9DOMqOSyx&0q0Tpck{$?9tV#TXV0W-gOE8702>SVMH|kr*Lp4hzqx6A` z>g@ClQIa$Ncbjo*$ib$%$_}Z8W=FJ=A7zv_!cjQ+t;ok9SLi(-_h6a>^Q4ztxnJTE`l$6E}llfP329c3u!@T;;r(Mo_*CpYmvE*&}n9?+in-kz!6Ec zR|iHSv68D;Ym#D{(t$*w4guX}WNa&olfkaU;M&hlRb+qP@cWK5oH+cw|T@Bgmz8+3H+z4r6m_jM5q zZ`O1h1pFo0gvj)V>`?)TEjuyrA_&ij%!r`Eu*0##5wJylnC9B5a+PDn(j?I&4M~Qu zi&;qk`jVpS=Ip6O8Fvv@3R&?^P(y#>Vf@d;VbCPR!07nNM#ku8b#HCBU(uf zbY?wb1_rlxVg@4nOJfabW%q5UozIrZ zJ;{;O13d9dN9Xn|ORp|H*4aCgrW{TaruGBDfXW!P|Edlzu&=X96uOaaHqknp`L5OQoTDAGM^+qZHdcguPwWn`Q z`g62-_weimE;y&&v`48Om`?>%oBrvQT(^a8(ymg6U8A}F))pt=f8YOvxdx&Jeih*! zd@%+8PQu8Dwt|>o0T&ivl=~GK_!7v^<4nM~z@?hgNBNG5m0~GHK_7iEfYnD3nXB^9 zb`ltl?EgHA?IQ^$t8fWnC6tKy1J@$^0ztD&t4oU*kGTfx5UjE6K64XZaZmMIQ@`X^ zHDpqOqlsVR?DtMnWqXcv%Z{lp-oNt#>bK0xgx8E7^hkp-6#KhT)5sFmLRcEctfSg{ zzU>m!I|%|C%d^&UX~~E^FOx5d6A*Sq&C?ykXgp{rf-+1* ztYxX_&TUbzz@{hbz!#=YNMNWyWWACS<(fQJV1yVmcfZWzk8$;k$Khc0WTlEjA4w~S zQFQoE0|?xy23Zc zsk?PiFHS~C+QL|{GZt3lQ_6cZFIWgDNI)7!A$_;a!EdJ(B~dYE%T(_pNtN_zjI+Di zjKao36Y_gEgpl|n4c|WVLg{1FyD-n6WC=HxRtNKHQs9KqxpfmQtrl!hFwI?HFx^102=%oweMfD)_1Y7Mn-|Ux^WKdvGke%6RuMspdGcwy& zk%U0+>6h6|c9iiT?8ZNfcBKx`=&9H&3Un)RD|zvkze-F)AwVTS&4iesJxFvyIaB(& zEStJ9`M`%cnFmoMc#6Vf9{?PR-Zb8-znY{fR3MUU2XdDpmG?crYp5Y4Y)LEX0aYb) zAXg%S-sGLAIXFiyoaroFX(s79_{)<7d`CGZ{0nO4o8BF*UACV~Nc!Slc^oVVm3M|N z4Q*O$-A~g1WrGdN&hO$rV1JQ`1l(Uqe%iropmc&x#0Utyzq*H+^|Ni`+DnzmNb4!X zO&cH8-Qu+DtvcF%3nPpIu*>={Z)QDAcpZ?q`(3_olK-#zdD65yh=iAmx7q$1MQ^yh zH)_A@fa?H~@ICR8U;l`Zy12Udysji)x+l9$z*3EA(5u}0{v6~(i`S~pGP}D?GEYam%5tX|OHoil5vvv-aOd{mGF(7Wy9X}Rx%;{Cdw$_v zT>L#3NOKOb>=uxId0p6&IrX-yTxrc(NyzpSvj}8O8w z@$Sdx=lAeRx$qBdz3Sug&->FY@dviw74~w_1yy{IE^#RxY~_;x*MS0X5{mi{q{>3h zDt-*!uXbxIZxZ}hx*)xF+1m5LHrB0R9o}SY$SgRfhJy=EAvq!LJRB&PA#nM>^bjz! zY;op|P&TJrQ8X8tctd-jf{x-&eJOt_RQqqy>=cqjJY4A(!Y;0P$ZHA2aLF*I`QJ(z zN*MHZK!Z5<8w0_G`=6aUmfF^>{g4dxzVib&fv$G!Oggvn)iQ{m)BpkKtI$W0#!y9R z8cKEoX)fBeLTCKaTbm*~dd9$d>XB?3FC5{E&~;=v=$d?usS1$r?|{761*RIk^$z>P z43Q0jXDC zBE1`)rB*Q$R*$U2(&7@9Z_2d%7M*MK31Z}dcB7;hTJe6To;c+RiB(|um7;;_=W@t$ zu``HSOvB%GL^4vee5A#HOaGP#yM2d!hmnHj=8i4-td$vvC$|*lal)zrOrdN7IZsbx z|Lk+O10ta5dM65aV$ONtbRKNi+FfeurXNA;p-d6S@L=vKyyE#_(IP)Zp&7%3tr;~h z+N8dO25`9taY;(YzV-c74FlqV7Nz1sv#qIDhFv#L9bLb*lk8+gxv{PXNE6bzl+J?E zomDnAOv_7te0w{%&5=vDJJ{Xn$KOW0g1W?sxx!hFY(@I`TKdZD3T!1`Bl`tia((r? z-oicyE?8}8{LCy*un{`H6)Au+l=VD}FTGC~?*e154+SRQx0oM0aZCK(<+y_kBqLM9 z!Zp#RT)RGnyt+J{Trc#bEt#3-q-7B>48HUOaG=J102`Bky$0BaFiX1!4k7*MhuQn) z8~2gU#@_0UJ!%qxaY@i?tyF>iPM2UBpAOR>$a_xAb6$Y7S>05ExrMuhTZf;IoR8c-Fv>9tg!nP}04xLQ9I`fA?6Jpkm>@p2#3`S%Ae7tS zb;lA4swd3tezDhRprE z_8e1HO530PZT;L_$R@~3eLVRaF|R7vr%_;bfm}Tm1>^HY(E1uR6)WQyWWaf|AxEus z?Qcz;N`bL!he63R@${2dr@n4H_;qxENo>KMc@5rBa(xlks4Uh&fVU)np=+K>0uk7p zkV|fGoXI$p=ah^KsJxT*z*P4JdAHIpW%xhT9n^aZC@-w{KPq8Gu_Ul0)`K6fAFmf- zB)?@jau-G3Yok>OjiKLEV)$%$(F+kOht86|aqo(Rd_$Z34(G_dICE-o&u*{H&6t%u zp!|w(Gh(y%+fgULTcne81LP{-UFnbHG{cgep>m{d)$LYI17#ZSyON{9ZPCwSP!;1@ z91f^)nAPvX%=-asL%6#b^h4VlgI&>G&?PB3`o7N!iw=Fi@Lf+s9SxFS>R(GftAX5@ zby-j1wNjh|#spYDhIkR>IZD!j76tfoNH>ChusT6&!hX|1(?M~;$LLG^t+Uu>R=XeT zeTpq@_AXl|C?90+Vy{+V6EPDp@`0~ePdqp3ec?Rvs}4X;IQRA85c$jIXGm%L*Nkg4bJsXsFW9H*uubx5tC+)R*n{W zx91!Hs1-hkezAP9EFt`Qmg(9<%$^{>dwi>TVzEhOi`F5CfCAovwWhdkd|qNTMVqma zODWFDE!P0m_G`(UqOeakDD7AFsR80KnoD>&)PJ=&Ba*0pbNR-u$1j*cT{7C_njkv2 z@HFuDRiLy%;q5RbjmhtUY3&SBhsddb!})e{emJ2tEq z7e%gXHO?B>J!L|twe7++*lGyM2(XU%;8CW%L%lLbOG=5)`C&{x^X$)Wu*68SroP_w zJosym8DU}TXuP`o1(5|}>&zCPqO&|zI?C1|rgYh{#}hsj2vz>7I?T8m7-@(nqW*}` ztMMf~?~>nuuiSlMveG z6*j;XU`Dd1I#M?KLb`X9SfVl^BpIwq0~RnIFy6yr2-JFM`9wcxaiPRSNQh-4{f(^& zdWnCDZ^xL>_qjiA=;|rcDlyF>sC)=NbL&gy(3!Vx#rx&VH+?6Gn_&9zt*}YfD(xP^ zgo+hCO^If$)A?nZFITt#E}D-0C+o>bC4B=NtGHRz1Wqs~>IFpb=kxvR#;JG1&G?q& z3;9`0V`vBQ`J4SksD14~4;Hjecd!@Js?!z`xt1TIa*cck_nl?!Z=IE@vrXUv->WK8 zO6Uz^VvxOKp1hqFv{Nn2M2_H zzHK50?BT|7w#+SdZZ&r7tX{9O?}m(G$b%}A-_`yFcp7xntV?9%5sQW1B?@s#>rH`A zf_0pua!vPoH&WEoe~ATtr6waKL_=+2;ed5ho9dOqmggLomtaF1~^i78p%>^qL$s{qUK{-MnAWaZL>|N0NZ4C1cwSGO=X2li} zZ;x`tJtNs$NHkD^`d>d`?<#YJU`MgOiiqG^xviQT=z;^`LY_$GZ@eF(@L~F>9c0?* z@(A24hy5grH!s;653fiPDTI2i&bXo)VgRAz?b(5{NYcB$S!5Mp^%Y2_SjoCozNhTy z{HqrCbJ?I7fkX?!{;k+or7OUz74U6HW|#6BEsF?O7h);00o#l@q#k}0n8rtOoY>DC z{|1j6%7$b{0M%Zvw^VI?pMtvCaR`8s_bcg|A@0ZAhI4=v%k~vpDC+V}yzP7ePFP;R zH7O~PDgDlg`L}JT7LGmc{&*6daj?m&w9V=djtgjS&a#Q74F}=|%Gr}JBs=A!&Dv(^l4-yyVwBmRQiL(X5S$38 zXHL9L(8R3Xoy53mog zOJKhiWh%?}rz+n=o~Qu6YWh_2Z^JewRzH5{m#|Ca8p|-6E+q;O9S|MpKZ!j|INW&$ z)sINohD0p#D8HwRe~EH7ugaTV_U!F>6Lf2% z|8~>aC1E>FmeH8?SlV(lALq{)R)agJ5;O&pbYgBqKxzjX`xM~&I!J;iZ1bQb^cRvH zZFJ;1sxdtT)+be=71t7cr{cZ93tw?Y6dg%`n$)&}%MTRzK(UUz&D(6iwcRLTeVJ|^nI)S87 zAu1E$Xm<3*bn$d;%-N!2<<`|NbP7S*1@o7brLk}hutT{B_WZ7Z5XC*fkBDj5j-z#FJMQ7PF}uUpTP6dtec&BuJW|HfG>JXjc#eNbl9@q^Iz&ym*x3O#aL$&+&q#MH2PiJjxNM!lCMi$GK}^` zDn?<1A!8$!wt#=rzh$#Ch^sJn(N()briWa<^-fUknKY!_YK?`8lO}dZ{LfOuZz#Lp zfF&Ww3#?CIb2%$5K@<6l9D7WJ>(fD~^hzZY<|jagoNzQfT? zKgd*XLCE*1mFiuk>&|zcna6mLWM;%$++2P^RptCgN`vd7));>IYK8ya+;GJ`n~Y9k zTZtkmTsuvsxY8bGI$p)c{rLD5RnUO;UvIzKvo70@N59ckI#|QEwI>FTM2K4N?h(HZ zU-DBwU*PPfXh$dz0^tiQmMHX;kTYjc=DQ%z@)WM9kCMTx1o(7QRN)Z_je^H<3(;yR zckV=)lVyS_j*fv)u2*h*1DJ4-NRY~Jq2tb3pE3;*b0GjFgejycB=AWkq+9FDm2-l@ zxb`3(7y zha45GGA_@-GpCBolz$OGSPSk-^z&NeDep<~z8cs;K7+&5ue>x0#?HM>pSF^&2{7C+ z+}I2~yiBee>~rD$NgoR6%XC4o-xul7{utH_pPH9gICRcNRF z+RP2WgActnv}@#A#uwsc1nMg?{#AgB6>m9yhDWAfX2X#P#1jw4Os@YXK8~en4W=M} zq15005wBk-aD@&(rB1Fwiziz~Jd1qH!!~J$M6exuTyWxioD1D_MDi<)d>e$D&x>%V z$+7Ac-NbH5hu;S384K@=j~Mv#v6&$$JRdTd4Y>{ZL#og^IZ6g<2C5gaBk}>!gbg$; zn~G^MFH#;$9!n2Phy(V|&B4vVNj^ifIX@ z9o=Zef<4)Re2`vSr?Cwp6G#DXW6at5iqeCDX-@YN5_+tHG))# ztU#R2pGl^`-zvxy3orQDJniCa>0zf>FiXP$mxcERB&ihcf;3S0-{p*rJzoGxpYYyN z4gK-cY<|k__{|PFjzTCtVg^&#HnwjdQkF&kPOrG2KAt#h0}v^=U<~?>Re0YZyZiO9 zl$>Og(`0OQ{hEc|6?on!M5jMmiLF*8?v#84y_q|)H-dZ?`K^heTuRzh)-13JzheAR zycF(%k6qzucC)qnD)9PxdDBN)PYHnB_8a(!_$ZPa-y;yo<1^a+2VFp^hMdQhN`5$a z9%dnG`vrX;ca!ge??P^YswKfl(nC%_PWaZ3TAOc-IWMp1$qTKG!5#-1%?rh5w1vR5>C5E zqo?}<&PU!oLd_{R0m6IiGmi)0bm*o+i{kLhB@UeEm8DIsdcnd7)hR)?%E}GIA8yICAg(7+subPNea|AQ96;#jcl|`@Iyr0f zoFGjKtndw?R|;P={U%$zpv&u$p1aQwP(X%HAi$}5F+K{VtOh_8m zOeWgibv${``+JJ>6;P!{*AOi``>-xMKN^27b#uUqx=rcn!fq2@{i>CFbpbo2y~lV# zvoHUumdUc2=qkPP&jRG1bS~cy3OpR&e)l0lNUL&=IZMb1RkLz%AgmuI#lKBfkE&h7 zNZ%;?g|Po%;9#I8`0!@xplXBkUGO#F(PdNbK<{9jV=S(X#BGSMJ|x+&)y|)RQAVd- za18rqz|CCHHrmv8$W>gq4S(0MRd<3jScN_|>Bo<6Si1?=Qd*<3=g+w+y5*K-#hy6h zV+?{S4ugw)v^M9oY+Jr?Hq)&rXEyhI>8)gw%7LHj zE_9kdXjyOW&aVIgj}ZVk6dzIIDQIElV12j_h#tgGxdeMO(0>Znl`cwKnGGcVTKEZ1 zJ1>3Fh*a)=> z17e{vU0f(92F`|iC~VJ{4%!NixM?j0?qom(N@9E9N+iTJ(b`Rhwe>frS(J?q37LyoI-ce!qU3m~#PFk{QK1$Ptp-*J~1`}vC7IQ(MNr|ScMrlv6{nOZ}! z^k^0@MI{9_=Dp8GtooTEcXo9TEf$4qRmm}r2R{L47Tf@K2HPZ>@iF?c>AZgQXU0Pc zT?a^5#$F>eHW?g>ibHARbM`uPg=vIqgj)?U#hHcRI)qvy(Pq^}HqihgV%ZQ-per5b zzn%~b&0IHfL)eNme?MgoTgUET_JkrcBQwiq7CtRll&H%PTAsdd6M25UeL89m&|9gt zDGB@|v0m`(f6Dwa+G&cSjr;ghp`RY=@>#wFiwAY55CEkuYj-eaDnNuBj?geHJ*=x<7@L1@v zEIZy{mhG2d4`(=LCp3Xe^vU+TUk z1jCQvO|wYMYJ^)i#vQv%+oWP?HS|PxP?5QkyLzz4&-_4{xTf#wwPX`}Z@3&}@jx9= zyciCEg~9#_-wSEK%6CrW_T4Y|4f9^ZKj<9sK{P0k`Tk`2!5pLMKgPkl za``5SU;>Okalg`h!Os*1;_o0%N?m5TrBP8xM~7JJqv}L!X~3L)wnGFS>5ROe@*qCL zZTh~vf#3imj=4o+2Dtm@yz#}G{IQsdpqPTlUpmE0t(v(!;3o zVIk51)j^wwn}>!7XB;alt2wmAwr|N~y;41mffkSkBJajeF?#|~*Nz^oe-K2096(-k zsKOgkcb&`Mn*=aOumBcyD5q|(aj$WFz`g&97L$g6}q`+R+n>7=GZ2ukev9 zhjHd3{?v!*K=JGWX+4 z+*aru;OH_kN2>u{&aZVhT&^G-%#Zo3dI%m+^a_1Q8X%C5wk$ zRMu3voOPeYq^jy&J_8?FXwAHO@N5yALox;(k?{h2huM3%Ffv5b!IbpMs#P@tpT&SN zTd89CA-wvK$~Xwk*@0st7nWrRPwdH@_gmCEF@t*1rHD=nL5` z_x(-whiM}J2t1)CqItN^SHGeQtYH5nC)o1$TI4$=f~xtWu}*KtTSS#VKDmJBZ(Nh6 z%Ll5iP*K96CZu0N)@2-PFZeV$57+^7(7z}lOK_uG{?F{FwEX%+Md~11Yxub7k zZehMGfvTm@PB-m90xo|_LUL&zP;JVq2mK#qUMVwQvEn)*^leIZyW zM2?j%s~@U0j0Leqgj+G~?fbuj*E$DxA9q_G@WViW3mtr`V)%rKG*LU_RBt> zT)Z;za_X>fqkK&`Abaf@R*xpN#cE1M;ZZ3)aJ=2z>GsLc$JU1l&s=aY9r3ff7bhRr zWFDlpO;b-4rn01}r0Rx*Ga`B$dXtroIm0VLLxG1nJu*{q)wT!h^%Uu?`n7p{ZZk4KS z7o@XRb7w}j))ZbQ}NsKhhk(ROTwCA7VayOM4PGtnK~GhAC7d4?JqnL@yt zLjW=tl7R{BSy<=q*P$MHJKbj&_X?Sz{mkJ8tGZ#85tR|Lf&KUW_o762L+`zn9~_hW zgE63^TJj)kx!J)^PfSHNP~Vx67_(-OF2ZyhL(c0h|y_p9BwO0SH6v zX;d=^n~zBS)PsP)&r-SwIE^?Uc^+#pb)7@T|A zc-ik0sK}Z7XHKiZ6EXI)DiR!QH9X~PDT&N5!(LMPZ+L#=;Mus z(GR~3*&4gRSL3z*hVqBrU85FVbEfKO{>6~bgwMnU8WmG%EAaEEMGyQcatHe_bHL;0 zBg%-IR27x7q6iOJ{wp}=Ko#%BX{fabhy%uB3-YHU|u?~Cebl3Wf z*N*{YkBhMdnx*$%ImLrlIYjOJxcT04lKLl@FXk=%0SaP*u2c{Bu1 zc?na5UKIhkTA>O7H`xGOpyEPg8?_;(5$b~Qg76zo{?pW}IsVQ!H(9TUmMoHKvT3qw z%EDjLgh{RlfuVt+!U7fzmhG)Xyjo6^h`K85inS1gZK$B_QF?=&5MU2b=ZM)siW!Rd zcVMO8ERiA+Yv+YZ+Np@-U(yfW5XbFTK*Z$fa;|A_1by;46>sDS zui&MQw8ZF?iK-Aq=BGWgE<`%}&PxxBEJ`W8c z!&)NkY5O!L^6{uKJ>JEGO!?8d`!P-yX?@$BM}Rk38Aar+8~U551@R12Yb~=TY`tqv zluuC2!_>ci6$Ir)sH0q8%>d`-Sl9kHw@y|$%I6v(9(WHqK!EfRvSX9?MorLO*k1UM zvsR!^z(E`&V~HV~{b9=!h6srW={z8Dm^MMB*xzN5+uA1dvJ&9@wPWY@*9_a%2N33ZZ zipD^PXaP@X^)(Zn-0e(1vk~}kk6{Cn0DDv%kK$)iX@1lMwvH{sTU50?pFl#J3DzCm z;W1v-E;V`#Fj%y_6*#Zj-1Yt-k;xT?vpez2C}CKV*rGOv=}eOH1J_WISQsn~vuek5 zE^6^{JMQSQU5Zcn)*71!m`Xf)SYp70%F zo1HtII};#wnOqb2X2*^Ar1$QpSDFg;X!5;M{xefYht5ze!ciz9LLIsKiUr+khqlgK z{_V?pXVsj_=i?Zt+OIv*xxRo-sV?7zFGUspnWSbzxc}>p2usf|E=|+Leih0yC&3GY zq6lX;&5ExwpI-quHqS?z=_=S}^YYPeG~f z+@L8s6})pEiB4b60CH=cSfwI_#}sKlc>g-_LLXD#B|L|dQ7&~+EWT2MYJWU{Y5KV( zCMG`Nr}-H_(&Ft8}x zqVi$$J>`HaJo50uk5XS%f%weRN0)amv5-WsG8?hK2dZK+}DP#nFg}_1<4KVsXCjNFBJBT zc_n&6-+Hw>@Z-_YDUrqG1O;MZ;xoEE`#k&F;5)uhM>X#9F|wf4SlV#TOh$#@bVE>; z-VC-I;)Ff)dqshs@5-NWI`^cRQOGv9Yz^Lt3)c-wN~Q1^HVQ3aa>CuN+!}e8p+<^IlN7$4EvUn#}q$Xadi9Dq6n+ImXjXT|ihg5wI?Tl5C4~%(}IW z80*q4yGPPt)q#erucb3*l`-Ag){MWO^A=+MA);?G;Av{x(oBO-nP&Y!5LB9CpG?8^ zKZ5~MQ(BTq!fElo8j^-F8o}FvaFph8pM*pl2mx_EnqZmRiO>4j(zBpT68CX#REK9{WK`V>b~3dYmC((f)26S!vxGJ%XsFNCkmJj^`FpxSgohMI<& zn=lYvaK4x=PZ!~(z#f;~iYb{3E(9?WKfxI1Q645KKQ}*j9AX`79qUvIsWxDqc$eZE zEz5}ef+{3sq9GMdg#{vw>}*YjhEVZ{DhHkk{*pMqaq0froljYt#f{q?gSPUMks~3H zfMbN$^3C>FJ7n)m-%B5|;8tm`5+n!dZ-(CtoVbTl3P^Yj`=e9-0|iiutMI^3A;g-X zDpt|}Yy8X4xc6bC`k+%o99=IG7E%BxS_}n|6t5AE73hLT-?gN=(9|Z}ZbkaJG(OXKH`{NLE=R(6bz=|SVOqoPr|4q7jSNgKe zW9<+0E%#sdn-4l68UnabR?-y=47^zzhkt09g&s4pGrDx88<)I(jx*)kiWqdVLKhx-Y&T@>lqDcrjthAn&rh z_X6%k(6nRBbLotfjh>BuCTLc=EJ?ZfWN`I7$dsRv^F^;)^2a)RHpR;AGp%PJ+X(I+ z`~1}<(81^5%^7>L%iXFcbI<|KO(~oH1&d=Afl6PTYY^GeqS<|_lDPw@@r)y$lr1J7 znD7ElbiOR)e0i`)&9}#+Q?45_rca`_5E2xIXQkFpTDoK z+4sv`qo3Z3ixH~RXr*0#!66Md6)t;zlR2X{Hoc6G0`14glk6Ab+6VmZE*ZX8KRDoy z%Hw(?rHe=-7i@0|3$`ntvQ!{7z?V24{NwHPATe%r9yEIkcW(4FR7EHed#~!H``5A( zwOEN`2$Ybvw6?S-XyJN_r-3D#1YOy`dNGX^sjQ6CsAsH zH>QHDNPmD0ZaW&?RQvC}!LYRg#(snE2#e?|fFP&H2}bT_m{Xg3PA`0j!B4rkRt2)= ze+@UWeYdc0-Z=|8Kx?R%Vx9#nTeII3;WrATtub{5)N42D0fF7s0H!lktVM*L_fJwc zw!~j$dd0qZO*Wn3zvhFL8`8y30r~ih$zha6uwOG=I8Usx2=G0v59{(` zSNNK}Y~5%ol{5=#L*hy~^u9hin=(HAuJDS|USRoGqi*10UG?CV5#Fq^=o#X^F0n2CQA z|L*M!o9lI!ZpH^&kc6#7tVA+MnmjCTX01qy9He(9!OoOO-Wl${?ZrvBHKsi?HGDs3 zOL!8N%v8u!n4L6jhlRaDyh3yU4Yvgpq152kq~SoHTRb#+QMz|@tgmY-x|Oxh7KKE- ze|*0X=qoI5bMbrR(kLyT2+tG}rJ#+#RYXOBghU7fRYF1S{|U-wqz*CgHxm;R1tkiG zMp{`ER0xIgfXcbBoxbYJ2C`Fi`TCo6O~=2b1KyX{4X62(wl<44`pRzyI1ep-4u+ps z!+br9M%FC%1vE9ribpINn0-=}Abnikbuxd~;J%3C7mUmD4ZpxdSw&k#KbNwXQ1_(T zjbZC473acp2qq&B!Vkh5B}1iZ(+Dmd7JybIU=}E>*2wjclPpL4CR4fK!BM50SwR(FgE`SR`R$AA#I~<-iQU!lug$sLx9#V5m@DF;C^8O{ax_8C)Y0D zaK)aogVM)jm8VraK;4<$nI8=fXX~M~%fIS!ajQx94q0we$j4*S5l-fm(H@@&xh7}r zsg#Nz8z)^`oPzC8?oi$!*6P>lOLl^p@-$=tr%Ew^8d|zmHOP5qt2ST;-Pcv1LfOlV z4|(v5aViVM*vM^NB0mrYc$fP{*nHXZ{=7<2Y%1n z)Z0{5&BDhhji4=+w6aDRtBzh?kzSUfK1nd%BDa)`xEUR7a2kklK8un!f_{<4Q76O{ z=@jXlU(ZzJFMZV~+Ww2^4gAP}kE)L<-D(hJ<0Mn{q&&R$uajBl*KVpo(>d(5jd9V| z6ayqMG%x3$HAxup%+v<*ot5Wa#{55X5Cm|2(JJYy0HlrzyV*m0$DQ%`l8Ek^*q_)H z7f_Qp-ALhTvrBOTw&|ypGYz}mR6TTmUHH0yQ<;W}ef;npe1!f|>N4jO*azeXq#vCQK>2BN=ly@g!4oRQ^iS05Pij=g(lWg zoehZS8rxizpqiM+u$bw)kdJBr(|q#oOVD(q9#4uJm06I@UA+bmDd`Q$M)}83ui$N?BK&EAlDa$ zLMEPa7;V7+_I$egnXxIm#I!OJm;%Ka63DQGPKFPl&ajOF+fT);7gi5b4bYouF1C|1 zpvhL|EpmtZ$q(y;_6%|SrgRbGnUQBNxfRhdLvA%PiznQD0exZUyXq%k|XHPK_RZ=N3~g;V^u;kr$}9lo7|z?F@&3(g?-8uyw< z!O!dxm~p5R#1q5@O_s;8Tw5thj|> zVfN{Uf1eiOmmer1o~f($xn)9OtQ0_1$w{%Drq5*VH_b}`3vMB|AY3gQK_M+no40PJ zm!Prex1cV5Of7+a$nzTAiRFE(aH%Y`A;yXuN1iI3GzN*xfh|(26t?9}>wyOj*lrHk z7J_7&7ea)-WYmsERS%@@ok9f$64Ds%Dn*HqoSa*;`gy*7)%<@?=m+WV?)bHHk0I`l zX4i8R$0iTh!S_VR3x~xx&Uak+Z1RQ8Y{86!>UxI2oZ?!C&Ozsa;8Hcj`QiCtb(LCI zo%XXU6kAkVR9^%#-~O0e|H<*ZjJ^{8x2CryA9ziXs=Rqf!#AThqqEW`g;n!a^Gv97 zR-i+c=<9D|9;e*b{%iD6NCMh#%8t7pi#mUr-4)yxwQHLUPpWF09If`|F>BrS*VDX` zg^gs5WVe-up4bm&2yzW2dVcj%DcTuzgo_=BtY`lD=J6nsr*epa6RW~pqW=pL_X!Zq zu5yPZnVrVVwuEl<$*pIK_}9DrE%f5Y#Jk&l7x=(GYypE;-b7@2Vs(Cm%#2SYJNHp5 zY_`xq;!h*o+|#+5rKu~rvY=qC0n1NP1X9KTKCx^v1<>jp?rNC_w~#MCNxR3`*~VpS zQUe@LR`T=f8AG;3)UJ0f|0%z&-0c=ZD)4RO!_-nKMQaP{$5rsy$ zdNS%vHHb9K$2Br)#9u|Z77Ye$-_ukm_8X`>LVRFj^O9k?I&Yb`%F4d1PCXyj0G^aFvQ`Can{CpA@b7soj=!L<-BW`d=#AY&iUhI6gQ>yv&dA!s1@LOlf>neU;W zERJh5ndc+#3RAfUF^nTvDBnP-V<-UKQ#vv0p10~>mk-Sg3ZirO4aa-ZgEn>d0Z`Q^ zZPhv_4^|Wl-k-2fKYN$Hnxx{IhQMmgG!&c3g=Ri|yK&kVx#wEiF!3uGud0|y{O~Vl zz#kT`N2Tp&`%-pWa|4k1(2cMtL>`(2n|Da1-B-8&0tJ2Qmxy(<@%HUQ&)e+s&CsY+ z4&_bbQ;+usfOu?p-^7Wv1$r&$T!_Z6^fm7~)bQ^mVV@g9D0nkb%UySsqKohxtQvJJ zSlg?@Cz4K50O)GT8lY$6*zT@5|4$);@_s|v0V;#_xFX74zHZ`C4tCp=9d!6U;9ha2 zt=L6QpcL1Dt#jWtj33R1;u(zMLUujv6=!v0ZKER+Q$?CcxtnI3BiIYZvhOQW@N0}J z{@0QM&S#Y#fhmEh3q;3U0!jEY+DU@S5?7%wNIiZ_N_$GXT$A&?Xe{<< zWGkvk^;nX_Tc?7C>GHnk?9WS;|;1>e^=Jm(2^9?{^R2nS%lCRs$#~4`E*JAZm}9*FI@+_c zZ*ya(=pXa}Up~dJqf$bhN3l91^iJUyf00M!i+v(qMzG4Z%JzpVKuY%dUhsNgH?mS3 zRJVh@_7WXO0AC=ZOQh7Iv}{dcfJTBpMAD*=JrjA$6~OrsH5z%+?_xyvQ$18Yv>LRa zYigr3WHKd>S;RnSd#k^1cmTzZ;a$_4z2&0y!UJ6GZC58EZI@XE!{I9E*=LZWRM?y- zf_4UOm*Ly!2kv4&)m3QvWF7dSq(mI}`OW#wx($jC*R$=dS?RgXTJtfFWM=GF(mFgy zQKIR(*@MFk9{3;W?f3)iZ*}vXI3QGbmy(#4&l_)H#8>38ni&9@@+oX3;8N>M%gmo+ zCf#EEXH*<6Ih%N(yCN?Q5k*pQx;NdE>NV}<$;;i_b0PjzMoW0cw7-I43zWVz?aYIJ zs~XolAB|{`Fqb(&P~ca|zG;L1Bk3-7cOVnZ^)BI?VmmYGAlHXgl|ZFG3IX<0Jd(H(6biyHQa>5ZB{0=tf^!f zfWx}6*f^Uc0GtZSudpc?Tx6H``w!G!?Jxs6YUBuLU#-~sQMTYNV18IUabt$|nzHLD z4j4JRW*O4qx3Ip+wJ;iJN?3!ORdsixV}y1&hOHns?>~OTNo7rAO{)y@E(PF4p7!2u z&@uZzNrZ9VHH!iD-ULNNb;8A%KNcQDz~$7R`)Cx>Ph*49<&+B^wB5`DIWzbso|<54K_E!^P_b3Mk}P`6iJL#3oq zM@j`lCq_;2XHD53BX|tQXg-Qp1-yLAyCOp~J)CXmTtfm^K$%tu(xatnKtmM~zFcs5 zrwcI~u@+@ppS^;1bk0sY1&H5XwhM^1a=)P!WOx+TE?6W=gZG#U;(Q7;X$>Z#H`Ri) zS&-R|zQ7PS<-$WDh=2Y;vR&en;}CvPoKf+Ze132}$N@29!P~r=0wc{H&K~N(QsTx( z$F!4kaC2}|A;t4jImvtu@~;5!6PSQa(h)i%iCi{Gt_ApsS~x0)GoZWh{_qig8oN1q zZ={=z(WhWuSWTReLd`1Qvwl|GosTYzXpjJ~Gd;XC$XVlnLl^Rbbb{!_dzo-6wUmM` zn70iE5khLaKE%HdIa>zc6yG|wdLGt?SWN%~bHxk93p$Xwfcqzvnz4AZPdf2@2WDpe${{vd^SpS*$01F1ugV+S>g5?|n2V4Eqq?6tu)X z`@e_;k}-}v%1nNVhP)tFK+Pi-Z1`YOtH#mwW6OCHrmv*}_U3r;yK1`uoiFnMf*9dG zQgc=P$z(s;d!-9Px$IOSc5g~*`vmR*@ENd3d!?e~k?~$CjCN#tofKrh($E<|MMwQe&XzgIwB;T~Vt3SHn2nN1lzlZ-6q^iAxMXv_(^ zQ}x@eaq!=ymrkm_i-{F$FeO**d|79&hEPm=&LKoBUik+qJfR@fHK@+5e@`<2ZFc4IQ#obB z<#6DhAB9%Nj8#3-Xn=KlEty$_IUujdUU@FPLQUNefSQ!S#H;HVzE=#OmwQUT<34Bl zd%g1D=s#IP%X&e{S|m&r(nszVu=6y0ANQ}|7$xl*$pg}9V0=xF49zR74(brhBiVZhU zZ)s1%28)uEnKC3?tN^scHXgY%!8&RWcKc<8l_9?U!ds-2aDGJxDGLJti2oiS)wl!L zkP9nj4nq{ehPfPr-0P@I)7Vih6|~B>>7tT%&#e+-h?iRf5KDm;6+1yGru?J{2{uPg zN6yco-mQRa1vgF;NpFHWnZjONdWApBNE__u1gfE4VnU`Zd6P)7_xcYvjPq^BOV{M) zdVN(fl@v^ANy9NE1e^VoRmw|sBGQGrmbtW2|7@@i*_+~=K&zFjmDyCbU`SihR!nLt-t0WQf2iygMcO!V%kaN!O-EiTKh8s{F z09FOh1y9WE*->{4^IpdC5irN#g@d}VzTL@#y2kRTy99O&j7!1RZ8Gen-w|jz(>&GR zU6(n^ERK0yE=BIerlZ zv1_5??%EIRRHp}j4o{c!ZeWD^vQ4gn`|E*+z$k_#0QWBCKIPt%iT3+zrow5wwe8s7 z6!p+hD~QR4$;S6dW5r{xT5{+YlXA z!CMJi2^Or8#8JfZZLoR9fU(Y|#iqrBqLJ2=(DNq1`!7dvBm(e9!8c;Qr1Sa56F2X+ zldQQXQ1hS%%ZB;zG8How6UOK}Mso6rS`5_LPkuqI?6V{X#oKRzBRcPf?uJrPFOcrP z5El>)zr+!w5fGZd56}+KM%i~V-43=k&)iew%wUV4NQnZ$JJP-Js^Z=fnZYn$2JN## zgQdg+nLkHonb9$*A}>hZ#0hr@E&+%VViN)N-T@#s6;1%iH>Y)M6#;m+{=M>Nwvk8< z1qgDiA>`wILr<=69CNXwAIy>1h6;pacu_sKyye)OquSbvIXfc6I*=Q z2BWmKhv2?PV1d9q#9u6LV2gaDwT*t{`BM$|-{36DxH9qHI$YIx^b;@`kXQXy&n;&9 znaqp55Io$jh=Eekp7H*5MVr@wFK*a2SIv;B0&6brTRjFTND)@J3WY$YKnvo z%m<3AP?*nB_`*S{nKxW6y3J)PGmy1)0QAMj`zpWGIykYoN#Yh(@faYN4(T3t|HoQ~ z=Ak8!_~V}~r?Im-@eP2kCe-TXbB++#%HeBy^Svql1WCFz+6Na%Ln#-YZNq8tF%~{0 z_hM?nT{UD=0aQSh<`u&M_DL zCjzTZ!Pvuy`1Bj;!;C<#0-G`(Axaj-8xwCEKK!XD<+;~wzWM>n`!4#zW+tq1~((EC}-;n3`celA% zWxwTLZ(EwF-{rU?FT>!SDgPE=oyUM7H~iHdWf;%os=n_k$en*bQYS%m?FXXOJ8R+S zm-Akfspqn5s9?R#g{nL*4!`F%g~6r=YHa+V;i_0CAG-;C*gPweFeC)6h2N@t2VOq4%&;Q1*o4znlBef zgdw*i?WcGC!k_lr3ty8x)T~k#EOSDum*$y8g8CWaH8~t3WURRb%FfHiA*P|BXrdu_ zL$n7WgqXSM zdt9!&#cn=soAIEiiE$enE?E1p`YwIwysr}YVJsp2$MH*44WYtA*_LAp*eop>Z^+Y9 zh81_j{cHgx3arY0NUOMSY#Gwe69L$aKNvFV+}WV?Lw516IH%G^uk;UVPt2XaA&4m% z^=X~mdG;i}9$kCxXLjO3wRhg*p(eoWXsUgmhKme^HpJB6)Evg)w4Wi-mq>+~2Z^yl zWgaR7A8z1!KsPi|n1k<7C1ke@E|~A}7@~d>a_3v&l$XqE*)v-B=Un^G-o{;8j3)A{ zO6=sPeYX-po|UoBugCgtDh4|J4;#r8I|*VS_=W3<;fqW-AOZXYn-j>Edx`P{(@s7T zm+Wsrw(tv&ye#d20m9mW5#oRK%3gJK?WvU6v_sb^enYZ$PI9Mv4+w5iF{Y~o)kZD! zd;-b^-#|#Nzxl{gJSbcx?J+r5op!b%Ja(;nVzm3-8POYP{3-Z^q}5R3sJR0FGe<@= zHX!}R)w#kAFlCGsI|X)G(BnytRWEA4?C|OWP&&Xk0XGB|4$13;0K`X0HwwNqUsTa@ zz#`h*hVfK!wQSZOMoxCj(QX!>V3T`nrW|a+IS$1@cg{v)G;PAz?Kp!K{=GXZpp9v*v zKT zb}K81gtx75(T$)r0(CQ8v*1Xs-KUxP(&TjHH5`f4uvHWzj5NzMOF~ugS&|Q)7QZ8g zGdP?E^^o#BB~Is6gU`ZP;U$Y{wXoA+%)ZW3>V#@LXcINqGxYFd=HTbxAHqj*Vq4Sd z*hRlg=`+@WhkdMs-LUltb;4&1{}J&9ZQTHN)#}^q{AYMEnZ75<-i93h{pJgvr}-RZ zgdG2!ip+XABBng1ydUkq-Ho;BcbCi$0Rjqxn-tnMaPNNP=AsILL%JkDYAE}Y3&Td@xqLOdZ?`Gl_Fneif|Qoa+$b#!Q3uyCeEGBRgPp>EWC zzd|H<&SX$WJDW%o#3{gRwjg*Vio`!oex%?!g?(P8z8{*y4X$d5h%^nqq<3tPVBQ40EJ#i!>fQTZzN+k zC}-RHUNj$^`3KWm_`-)8hTnQOGiwQt1Hlq~@PYWK@3VO`t6kh*%!HxDA?y!oGi9Z7 z6NHe=?ab}>Q?{{dOt$TT=?}!)G9*PVB-BlGO>}01pm6~m)wZ0sg4mdG(lFrE^bF7I zvg3LFc|I$jMtr2Rb+C1i5XJcEc@hdL2ufZ`TuTN2*VkI2J?zMt-> zD6{gpmW7_fPe_JgHpBXAw?gJ1MKlra9;%Ih#{4s~OW(vgQ8|0nI^^2y(4Tfs5Jo0B z6s+d$V^Spt>iO99MGb9ZiG1yc)8MUI!Zzt(w3s2>g`am@ON&nHeC7_(r&6=Hv4 zM&PI4(C2$PSl7j9N45N(B5Ztv`ro?37-k#4pPLtIDi)`ijGebUTtZdH5-WihEa`wi z602!6{2H%5m^n7t)TxSho{0R)^eyxXvyIYE`VP73Z3XBAj^Ya@uu5o<#Zr7)n4~l%${=e%BPL7+zxuB7~OuwR6q`y0q#0t5I}z zyW(^CAqjrwX=fu@X05ot8gFkMOZVPsxnsx+w-@T@ag%?YNTtSY=nL_Gw;L{#8VvU= z`uS)!f5d2#TbqyeWyZ!ein;~v1ZXHV&F2Eh&-#4KTdPg=i!AjA8M~Xr<{n3;#;7`E zVJc5LU?>UH3Pog&V`(-yST^Y~TIlYrA#Epz5BR@+zvKXuw5-%=ZgJEKr~70ldG%zp zf6l1CW}gjc$}Dhu$Rb5C1EER-f4|f}=<=N{1dpNn!8fZcdQ4U%nwnhtkKA%cbh8o% ztOFH*O9X)8R?~2ssRL{|s+3T|VbjU;#7+qe$2+mo@let$a%CgGI0SFZ7WP#FC)B}d zZ?Z4OD6M!tXcsrT$74$v*Dva)WY;gyXms3})6Va>mS>#}x*gQqZ6^w)QzTx-?nQTB zQPWk4(rNMgq3fLkADEJpUAThC!Er*DYv2EI))jncfGtkKAxUpG+%n|o{p+! zun1K00}4%2mi`@Y-UM%L4*W~}ZVxG9-T%7{Oj0%kG)f3c2Be{?Y$434um~k;tDl_y z@M_A}KJj)m%{R?EqVYGoe%}5e+3g0-o;t&c^uxZV)gUu#HEaEuEg&}JGyw%sQw&7I=5t0gX8& z!ntiQwe<^&UV6M$2Aw~OxWbZ;R(}tl^s+%nPq2K|f)3>07SMhY45I+>Om8?J)96BQ z8#Z=Ed^T3}ID1Z};N~+-(b*7EFFW+i-eY}LXNZ1Q@0jQL@#j^_6pm@@;%evzQd)<2 zFIbn+>PI=HznGIL2)8(#Ee0lBMS?v`MH*Tp_*Nz^S}XRa-rQ7R0qLus^J`X`!?B09 zZ%RT>D8QZhnpWwAfn1`76&krFoU@gW) znqv53T;zUciNa()2(UYS_e~|fMcg|l3PnB4h`XO@3->~qd7(|bat*(O?C|?_rKVUp zF)EH4`PVw$xqJG97d5nbnfiqTROi7=j(@=xLl#3@Um=bz4SxmQA65za4HFw_%}L&Z zo)dX7kSiGfG6q6#oeZob5(PU85n~7rQpE^TOmk1q$Q05on27CUq&Zm$p-r?+w8gKh zc}UOTYLnT^KLGE66xB-JqxWAsOg1ae8$xy0%1*h%4m3+uOTLNs{)u+jo;!HnwsS6I zTA9GCrqn4Q#o=PHF&xK7&Ux=wvu7(et2paM8n$&kaF{q3($H_P#XOmynnxJ*Js!S1 zB%Cdd2SKBSs4<>Md>9Mp){EO6xZLuF@OWl4k5Ej|0K#xCX`sr>J>N{?xP!-o;BBKM zqmjyli8V+$IvanY+-WT)+!UBXqv(m*nbD0U?GC!#TU%*%d_is_lfydn;e*$Oa);a1 zjjO>HdKohYMkdJhuPbo+MtwSGJ_j7}udD%w71vR%1p?G{%}?mc8DG~+h7+~LC#$6V-4hn?y5RJL$q+!9ZN!)k+C)n8MW_0za(`B}P! z+aRNly7LY{Jfj1n;s3TzPA+|byzam5W6WrbF~=EZ7-k5m`o{c_xQN*zjFQAWe0TUx z7%52tC>?DCR3-d1;0^sqn0(Ic^=;zHwKG}!3O;*^0UteuUs(9dD5mQsa&YssvjL>C@~PxFMY4Bn zNhwAO^oH~UC@sAyhAbP)r*8v~;RUOD<~z|pPhTvTl}+C@%VJ=pT=9QshE}PR_kdfg zT&hCY{iH^xI33_YV43{F&Uk%hIH?q7SGrJQvTLO!d5?=6*M`XbS0IBc&X+L7rO`@? zOq?AOoC*1}|OLW~^I~!tcXf&6z9WE$VFyj)a$+m)jP> z@qjPQ{L=C94TqN9-ll%nvQo~eqIe6fG4`(@mwCST`t*k|fppZP3YkffcHt*U5R4my z$L?G+$=>j2>8j`F<5Q=0*nroqTU8$7${mux>mbl5^sX2vQb)S%CzZNwrnSV5XWE+O zV%)3qOE;W7d7#hB)zioE&vHu?4xVCj*+#zE?s&w$i`BnK9_hEf50Ry;5%)xGNU$b;_X$LX(&5(}{lO`Z*4BHy;p5T@Kiw?m^#MTmW$Dc{ za{OE%o!S$%%G>Z9`dvFsfZ|hfGWtW}^T3P6NSqK8^Rp`2a_9>;RPjqQv-yjsiAUj+ zxId<$xId22%Xj0z-38nuSr0;a2U|sh$-CeiRJ4NGV9QXCcmURyqHusjUtNqX;S~91 zUknkaBkZQ_n@HX$0CYnKvoi|0pYC17nGxoH)pxpxv2VypzF~V=Cb{YwXgOw8@s zU%|b~0{&ffL}LIU5ONXsu(#f9Qnh)VsQ15KV$QmXH}2to&7YP{u;72=(OEH zY573(p6e|bO(?`}xsnF1BWm63FM*1HF(*|2freaY7au(}%t0Xwmj+S9%{!#H^`Hk< zm3MSeiE?SCV5->oKDjEzV~u96XTQz4zRFk=l)`Ssh!pgQ4ej2tXx+}Xfk)cY3{+fm zraqmRuz93vY%{tb&nAF?mwjvf>SEnO)@3pP@9y?ZT(pO(@>NKz37ME{Jus^Y{VQik z&7#0b5F+2u+`Y2yh!9vOy4a578Zdg#Z_U7EGoC9RYBl~exs$?k3KcenE229N)uP&} z`s}FYt-Q^R>lBi4xYK0Nv21%%cVl}R4`&J-pMDn9HnmcUIKo?CuAz#%wwO))@ReNA zYGC*u1r;Y1=cW!KFA^`(?*89f_4?TbI=`-7h~d6rnje{&o4FgdJ^6o??jn&R-$uTP zVnn@txZ{A^b%#PlN^`B;V*J~#MT{0P^^o?B_Km;-;dZb+!)|NSN5TRqtXjI%6hNA3 zY;9lKX;9;;p;HB@Hf*8m2xiA0U|_mzzHEL3bE$HvVjjU$W{AE6eHnBQok}u{F7xN+ zVgcQ?CUdxzUiopU*uAd-S5j_SVNfgGu5`PBKKhET7{(1L`r-w@l&yk1Nk*DB%_5JQ z|DImK1s&ORg!)(;i$Vha^?lfHCL=_iCsQ*boMJqkK}D)a67&F(I2qXX@A`+#P|3u^ zemH8lO2a?tO@-;NnC==7%Ay1!({o$?eG`W!G*S!76oYQC2I0H0r!c58vlCk02;%i@ zZn!)Iy+tv#sfn_hk<&&;U8#wxaxmucYdU|B=R}3Fj;ifRgITQyEI^X~(m0ax0nyDWf;87|(RBkSu#qa!D$zRP z+P9@A+M9V6W&=G5%5e_XOZ>mYI!{7Y?(_55ezE;BrMKW7uuGU>XjO_)@1x%|M#MnI zK+Xg2lyjR3SqWMFfCdrLf0MZWJ=37$88T?V=v3l|RO(dHR#-|lovG!fF|y0(&)KG; zXv}LHHG&&`kEM@{w!@t|my5+)t2$7Mw?T(P@wU84$r9_0wm^m~=; zJe6ETgpEwn!V<7ZGix=w!j)e^a_9EM|3ZA$eg%L9lJs#EleV-nk&+g+)S1G^Rh5bM!O^&#{3V_sNWH3F+1Mxy-M3DPcqdzl^pR<;3>+|q&Y6DJ9 zbZvC)YEb`V|D+t*h?Ei9i|&i=1+rGC7eX{)9ZvbGj?!yEkTkXSWx<;hR zH%m8?03B0QHlP^2qrJbqe+_;W-YIkrn;1CF zCra?7Id!F#xTxGR8BmaO1kl!7&r&)E0MKntXQ%3~oUy#fyvZ7kI=?@t2SP_jd4eP5 z%@WRA&GggOg6sSBErg-gN!Lm9oXEAXN)bI~_N{rvie&)^Up|L@4nr6J>kAP4f)D|a z>>G|rBXlD-6g3oGMg&4c=PD{StI~5f4jzL7=S7d4=H6X^Y@K9)SfnKD!{F5%{evb0 z-z9E@rl~BqB-sK#;@&ME=&g5+QUTx1lvrmT|EU(gtb5YHSqnSIg}Txm7`~Tbr-Nb5 zvC?;)(W=C7kYQF-LtDb4$=Zrs)qO_~Rr+WDNJIJ>?(DUxyrTYT2>(3sC;!|Zggb}n(5`>X+6>;6f1G7IbYv4u zC;9DYdR_mJ&Rh=zQIE{V7iL{VP&j32ZNBoO7cRLf(8#?yoUByr>&h#a{15@|UR}F= zX`72M`gbDmdCtGe`aXNx_onz&*EO89oFyon2<&L{*Vy+%Y)H{iI*a`*Lb}lE)_Ku$ z?mfmxpv?rHKC4q}%k_d94pa1u0m^zI;2M(hP`FA5`R4i0*E~s<3~L~+Ax+5?zZ5V&S{RcY+lE{IWJar#5WQ-4_{Ye_#zFT8izpjC11J_m0LB=D2Z09c3{H}p<>$zxan!#ce+7#Vh6+~wWOw8RAh-oLb{In4guOBK{3E!OHH9ir zIn8vfK+#AKKy0~uGf5%D;4}%O6WKP6Dqfc@!h`?^BjKbto>PyHl)_^B$l1Hz*$6LA zZv_1IsWfOWp`q}nT^LY8b4Ae)N&~Uj9s)^&wDA#E z=hs%k)s+7yh9IVW=Am{6M`p-Ifl9kBaKoRg7Eys=MAnqem2eNNxxFumavOY<_|<;NOUsGThT^7d;~gD$>a-t{4@HrFL!^QrHC+}&epMp<``BWcbh z^QPoYftg&Zh%s5EYE!U0w0dyba%1LDV*y=7Q?7EMq7B;Z>lr-$`zO<%#&cJ!sq+Z? zS`TjMWN*;RzdDy(4&xectdcW-MVWIjJnf(4~(`q##eg z8i+JRYov0M-5HG-ej0v?@sDGtGMDMgk28ojh_6Me0gAN`)vF>Fx{p5n*xHl+QRIts zcl&tjyDL%SS<{dhwDQI&vzBzRhVRQDT{$~DW#u#~IlA_@+(0QDa){C1RA~s}oWUy{O z_y=2L6rJpYd>eI#)ru;qubyYYJ+>QME-4B9gIEV`@&EGBtq^948>F~364g4i*h@bO z!Y3iS(IAU4&pj&Q9zaFsg9{eHFLtF-`N&foINNt?<_gc&mF<^<_YI<#PL+!Ydu!~C zlcJBO|C|vLHz6kWiZv4Tv)dUh@HB^C1%3v zR`Xe%CziK08KE8#9udsJqW792ziC9~f^M5{n;UdM+6$PEoHy3Xvqky15FCE#(Gm!c zD-nOC2g5b!i?F~6s`jm}IH(p#Vx3&E!I&*9)+>M`an?Gyn0pKo-0dQ7-(j2TLy<`CqDp7tEMq)#X+l3bz8djGjyV!CPp^r4C2XJs# z`9g#FkiZjwc&Q6#GFUOT{=X^#X|?J)Guz&O&UaJYIi$wW*Sj-0y6uSREvsACMZ$T; zYd-#mr@=8^GD4d^KiruSwp1FY+Ev&`=R@@aNmEnOQ_@8xc7leXKRjv)81w`Uqoonm zBuj2R_1|lM7rS5Bwob``b#2RJl?@Tn%-(;6IbjD#G0Qvs+&p2<1w9mO1=WuC%*KqiM(sOEnFaP7%ZQoRuRj@Dgj`ZD{_WjkmK% zlV83$g@uvmb~%g_IcrYjl?l27W$Fo=W!z%U_>5UKp#FH*0^;C=ccfoow%VoGn?C0e zsN)v<2>%SMKtqlcfb$^jyY^3tI$#195|%-85~6%nw0nM%lPTKR1Wnl`UWs@FfsWK} zWBs6{h3z6ZUY*KcUqORX>7wc#pNM;0t24(sy%qq(!wfq(ZX$18cX^y0B2yxq?$}?J zq7Y8~=L6^f{ zRsOd(D@zSsd4d=#-e=Us{FOT`z#Zw|yR&X?oo^Mh{#Z5tEWZ!2e9825TOF~5`aNWj z(r^MpQsj|3TTN9b+V*^Y?3Q=$Inr+Ljj;8a@T&O2pI&{%ekU)we;PJFJU@IV&P|`E z#Q9Sd>ec+!d@ZQoH~yBRPpt0)p|vFs>@LYJi6_ZjZ@~EtNDa&o`$IYW0%3^k{i95T z*wq|ES-V~0^(Z-60>%Kox>Q($`tF?m$Ab4id&bI!`_)=bj zq?6=b`Wg4SeMi$8AV*8|(0C7kIPjQoOLH13H3!g@8&!I9ni!mtIMHSEv97qDbym9u z7C8k{T2@^0c>U_IyA^m-`q%~ws)P8W2Pr9!V-iwIT0m*04QgSkM$`2slBY)({bWeh z%>aa6$Gw3`9br;?*5Y+mbq9RW8+voKOLl+@&>q4TJUg09hI&B{jA##aZ-Pu+*xqy5 zI@R8KeZQStx9;PA17UH;Z$hbu^`g1+eG+~l)nNEq^2m5LiGKDS^5mgObsacxy#@@L zVrQmJzFPfEvyo|vYfWHk)cA)uC)qm|m?~4zi^(p98mzYlFyXtq>1@DgLlZakO;bh&|oh9iK1NGiW9Am1W@vEW)hB~7W-9PG!E|O zx*Bf(9duC>YVdMAH>6)RY-#l3{IO#4IdI`Q?oQ;~f5Z3e@&5TK0OIJ`(7e=n-wS|S z7F+??vyayi2E_fr>iJbvkQ+SU1mwD-TW0eE4Nn@`Hc2%aI(DU=FkPwg9(}73_AFj)N0>y4pkJuOHLZ*NR2@COZE*FM))C?S>il{pS;{v2 z1YNT>62L16bHBD7nDPp}^=H^2jT4FEbgV^`vs8GEg+}`Miqg1;2rbHnGW`?Af2nTO z0!g1xdPbwOaGOD9lID_|SslVt!c$BWV(Umg{@j|0A6(E0Zo#+F=%!C*fD)l!!%H1^ zgLeu-#U+Ps9bSE2eS5I84YLh9%!|~X6kk|SjcjsYZzvw)g!Po+M@me~*=JL!lIUHF@H-j#YZUcH|n*w<1P-nSMhu#DM`zsja>c7 zdyM1OZwKn5HBUT;iuCOf{;5>?x+EsVNXqTAFTdxh5MtJX%8rFy?bdN0afx9K*OPy4 z(*k2gVn*^4=3QFU@YXg&$+JjMb#+8q7!*#H7-Bf8v3~5tj^mThp2^~$j6NBS zI7YtJ?X1BA@n%jJ;*l%wnrZ%^F0Y(8dJ6Z;yC(P%NU#Fwt0N(AF=+Ljf_o%aH)8wz zg}Xnp(H=8SoSNDhv{p1dRA+=Cv6p?`o0CD!snoPl@&zL@Ih*|1WgfH%2#xk?@CK0^1pvBKeZ#gx;16_<*n0LHeo)lWl&AxDaxr74leL|BEG?pxWl z0O&L-w_~zIQ2arc%~pv$BJ^6DH>v!jpx#lzbmbIbI5&uaRH^Oy5+mF5;1q#0TD%*$ zMd?nt64X#Y^ZQz47F8;{AG>iekrMgH3|~+^w8*<)^2-+51-v(?M1tFc6wa7HJXCWo zfx?TV^ET9j>?q>lS%LkbVjWyDv9pCsE;}^g>JHqNX!ij8=JskbG-hF?!~KJuO#ndb zb2k6WZm5`j}j;ds2|-NyNel9qn$;$ zdaOlwYj7aO*b%?XZN%rE_d?uAIv@NC(#|Rs&^AIC*i87xpCe}B1)$$DPV`lFL>P(m zg56-=WZrD$nsUKMR(r(Z9`^+<)oob2Kn=U>@Y(avUmyA8%_85SE5q2Q)DQXSDH3Cd zd%1eK@2vr)G)782{IYFVO2ONNu9nmfV7#;1BQ= zb2S2BPzNf%q(7lAd#-q9nL_l6S|0}~gg61%U7}wC5noF+jdmsO3eObROEA;$)9}4P z9Pk#X{d*`2p4Mww{@fOy2aXaJP$YyUg(Vw;v@Nwipmkg+ua!@NLL=(8&iJd~4MKm5 zn38f}5FU2wnZ9Rx44oL;vvvo)<ZJ-*LO9Lui~G6LE1JZwa1}IM$-Rbgr#yTd&Cvklaw33Wl4TUTetWxU$XojUbrkr0nmu=Z4H~sI zjWvy|n5(<1`-MjFL;k_{e1qJb=JeB_zw>w)a|=ofN-d~~efGvB5d=F=W}0aI)h%nd;k&`!CRmK1o8mow?(M9<@7h`BZ$;bCH`y#Lc`V~m-4^1;gn`_SyA9c zUK`NeUt}wrhEFVw+{1B@ z#x=?iW)J-IytI-L$1u9p%>mEiEuzJ3@s!<3K5 zk)PbX&EHTzr~fawltSY=dTA7BjRu{Hyg5VnLTCXEhE4=FCrdD$d7;3|imza@ZH6A2 zxCcJpa#q108>19(1+}R>Z@HWB_+_lj94scadf8yN~)zeMVcKw%y$@v3PQgM zaYn7GYJ?b;^Qb#1KbSr%^V;e(EpgHwAKln8ur4<`dY13rvgB^p%Nc;}2N$!g{v=Lm zgSJ!IY7tn*la-GuD}Gc?&N#k>(i`r-mHkfrFb~NEH6CgbR-#X5(3^~MS>r#3wZuh( zpi!Z!O^)y%#Yul4Y>S@-TmfM7QznM?;6B9Gf~~p3Lww+_k)v}5u4tz+{9vVXaQ$_z z2rWqah2k1bGRDXz-%YYbd-KTg9=Va*OU*`>PmDXubQ7Y@iC>yzye@u1#Cg%bvtR#? z>CJLsSU@`Ox!}1FdzEenyLt#vDBjnZVtydi64igUxgNsIAjlv<0ETs3yToT^#=|+N zZ!rx|urZ)M=zQU5c}^69E=-rwCe|&Kjzl4bQCOBOi3v?*_*e(i+v>-8K`m%|Uie4w zBe;x0@2!}?NI}5zr5xR^nk7$5!4d7)H(;O*(3|xlsO0hW*Lq~r~gY;qo;Pf$Bg$-E#?#p`cqmltrnAS&W z1Wj!*uTFA6eBR?$V^f8QK$Rp_9HNd=GfGtZ>zX#+BnQTC@f7W&DP9=yRc$=AbO4+ z(%zHsLfLA|c?>vtRBLy89=#S6@BWAu!QG|B0 z4peYxQ1CM*#yMuBv{}5~k7QJ~jD=wpMJc{8&AlQ*kK3OuT{3%aF2y%owqMO2vct?W z-C^&eo}@+<=CI#I;XJf8{h96IHm!gg6NC~7z0IqzmOc|WOy5R8)5p|**Ym@k)`Trs z8SSWUKhP9D2?2Qgd z2EGOmc{_u$Z8*$}J}|8io!X56*3)X@N!0=(N{7(P^n5O9s!nT9Q5-_lEQ>j&6%Ft+ zi=pHB>A!|Wk&9sGL?Jq3;YVGQkK$Q>wfe8VBD|wkh{+h*EtP-RmHe=we68l6Sg~iZ z=bmSORPDL>ru#}l?W5D<)OT>>A#YXiwgjLDW! zjYpA5Q@28!4t&-5@xv9qpLdJs#SAw+-tXO0=!_0o0IjfR=acm{M!iP;dfB!vx3eFASP)ISPrC{E`-Syi?DY5Oy(VViK{cx>v- zp*K=)HT!X;<8x4Yv;9eh2)qKa0`j*O7zBM{8yAS?yg_S&&l*Zq!}@BtZ(m1nHA3GB z8450jwvg5W?oZ*L!ggTEnT^t3?ZZ4D*XykVCZOM*NGdy82-h1gIzf8CXHK&D;`8=D znp{n*U&G(ray_PIm6uu&uRUkhW*|@&4MUD8^++6w9Evq8&{SqpQW(xTo;jZ1i#=FO zK!;?rqQkz^4?KO)x6T;1L86mn47YYr_T-VNkw~&xC>t_tPP|SHD&ggxwW}k8Ay4f0 z<`+(1$~9|MMtlhDRLc3QcZB?3F~*Co$wFLy0$A*V9*`N0F2&>Awhj65r7$KWujG8O zz9RI1HlVBC%GpZU=$iTG6OVz2_iZ%$7=I{uSX2t!}m#h_fe$|j6HEJF# zxGWVxbFElrZvK8~u#&3ioA^% z=Rg75;yi7+qSK08Y}CVuR@I~6>!TzT$KAjNipJQ>S1f-md6isEDlen%3a3dhCFr07Mo z_lI^VW(TQjyk{BlS|PoxO65iFT!J!h_rN0XqzP)>FI~M#jB;(As%m{Dp)3_e0=LEO zhCy5SWOJ5&?f7uJ`o&5<>c`L5fA=F)&+WP^5No77p}(eL&p>pmMm-1Z(3u`PGhSG? zcEMFLY|lT+^QatHB*<~0g$y_8tvRj1jb2)bvUqZMMbwzKg=t!_RJ%Yf0x)BHcMF1a z>m9%Md@FsuyFWUSk!PVkSomGOw#Le1ljS)>AR)eYjZ)>riq~VvK-}Y`6fz9BhHOznX)<5b| zkF`Bn+6cA{v)nxX&5XC(UKNjKNL}Hj=Zrrg3}pP|XFc;tR3lF2l=~$ANnQl|65l6U z1peI-%@K|KK%3avW4qdTsd+(soWAtcTn2dcNzCRNRIo-`74%<$T|!~Xk9OdQjT{Wg zgk;_k^t?nr6R@hSI?gEN?UtpN*abxN2uFG0(sbvXjio4c3rq=UEa%b2?n)U2v8u)W zn9xeAbIr3FibI5k#4*BL>0Ig5%W-##1&HJ&w3p=b5zax0S&8s{Z4VFOBE?ejUN2YNbbaf0VH8H zfU!Vg*%y!#@bXa&@(~W0D&@K^ye;KRF{~o0*r24wjSr(~miCtOmfI)xcf6gW5P9wj z919$y%pd)M91P8|APe3<+&@friS|kKR?83q!$rB_?a`-8AIHs;*7+o+W~XKgly(qA zNba(yfh{nCemU#?KBnqfjq4!IfFCURu0nSfLchl^2p&{Q>|h3I-4Z71rRk-$h>w=C z`L&&&`~gw9+3rrpE|>x}w&}gj=bfQ<~gI}3~M^tkV=Tz5S7r<@qtlw zBLh!|1%l-SDATh75akMlQS-EPS*-=WozIxG26Nv2nD>?hC#Kh|E;VUS*3RrLOtxgV z3u=mUloexpf*Hw^Lizf|@DmppBXcSXV4ns${B0c=1MXdeyDfkc58_pFZC=VQn(LF`^BoalgK^ybK1+N9iz>Z5b>FuLzSwXsL~E3jXZK#4Hi=y|6UzG zMAslPDrD#y?~SxXl?rE&@)nOWO>%nbWjcCLg5RY^nZ@Txh~oJ(Jx?Cf0gzG<{+@Aq zmpjL2k;fw~US~{`!v9hbpL+`~k$*U2XOs~SvdS2AB9Q2BY2t%*E|B1sA|{@aU#KZw z@GsA^mD3lcXK>TP1(&E-woVPBF9TqZ?lT?C!%=e=2Xl_+@WEi>XW-9F1RWzJeTOOg zga$our&AABo%AskUDlh7UaLAm2d(v-QvlYWAk^YEL{B~3*+L&cqMKjw3r>E7KopB|AR2bzcfTPd!hS z;|*KG22(mB18GJz4~)Rz`6fc*8{%%b1(n+Z7~P(CoVfSj*?ZAjIZsi5_zmroqVT*h3da7Ug;o^42fkpCb{O*Qsw;6*+WJ#cQx)Vs)MY8GTk?7w-I#5PSyd+_Q^1S4_m0 z|JFcV#{s~=^#|xk{;~yNe0QQXR^A3&A-m!J7zfs}eHFE)bfqvY&lWl>rLwYf=OXKXM|8gUx&1J<9h zh#YJcM2G@JK^X3~2Ji`*tWvdlc$W6ub?kJ@UlMeYb&*vkan>KmY*jlU&zUn~pJW+o zlSeD&2a_LcL$x}IG2n{B9!VIh{pfarBAcgXlbNq!efB~A+8F5~1xTnUDs1Xw-s!Nw z8XqZa3V+umPOPJ#5CEqCOh*ft9MW-fJG(SR;Q3Uym5?QB+8;~K-PE7^`-4l&W_6+nz0aphx`9@) zqsPhw>JoG1{>+Tr&mMmdztSak(1PTf!t$}B#TXCaS-&x)P9lOnZ@Q%H>OhT zqhk0M@KNAtd4?;|HF>v$2uj-oZuj(h36KY=Ka4ABAUW^=+<}|Klx{s%pM}(o=vuvp z-->kU5rFHXHUG|uIuZkQ9gx&7uJ;iI2(X6*g3r{RQeQ+j)m_Sd^RVji=wtv3+f;o( z>j=jDGmydycK@Bw3>~MOT@8zvQnwQ{04Ck!w}`rru#n8UAs6heYcC!!+D3z>wc~II z+%Vr8ARW-wu(K+}%;WmI1xW5=$KhT1TBx*7#3j~F_dhXV$ni0}u+>>=hdE!8iE)6> z!w$4B92Ba?M8Y~bU;$%Th_*rC8g3}5;7jc_l;z5BFlcG|=WS|@5j0>VXkyyNjt6lI z1FEWJ6=9VXYMtT?fW4XwReHaCrN+e5OGWu3VX$A0AThWks;(D^V4kr3^4#S;21vkH zxBJ9jOgbg6w!0&EN#>)RzOemz3cwo7hEkoWE&r?~eV%g#2rd5w;9`8qyN}qUqyl}p zoj{FY8bs|bSVZf|$rhYk3DgS@*7zDNNO z4#aGKxXkB)VML1QHscuJbd4p0U;TVm>qP{Oug+BI0t)PI-%3N@(MZkyyAa8<)0!zS z*HX3AB-TRGe9?Qb-pNtDknY7M5SK`M|HBeDKKF&{uMs2RX8A9K=sE5(?pDNuIKX;YWq z8~xTkS3X}pKMFm(=543G0OcR-2uiHAm$6}%fWW608UE4(t*MG)2F+L1XXyss9+OBg z&Kc|}oL6ugMp3v)CH;?0Bi0L{4{IvmptZF#b|=KG&s(2gl{t_|;72W)F()XnH@=8@ zgIs#r_Bl$u3r~bKt;kJ}tKgeyF0~_i7!2yHeBC87@i4e^a{R;@e1a_y|Dmb4G`IEX zgk}Kp$mp)s6@TQH*e|iib5^4{rQKg=5M511{dw;`Fdk}6S2%N$`D_m0(OrFht$uF1 z4TRw>u$P^Cf=R|>X3&hEhV=QJU}{v0Ug{sA>LAi`e{*u+FsS?iJzs+BYNiR@WWDh$J0qoU+T?2Ps zTm^)-_G1gUsUNg2tF|+IrEW>^J(-U+=jDC6qJ}3&*2`7O#mXKL;(-X&*@EWT%hX9t zmn}j-3QrgQr+v5s?I92+$`lIi>f;qAeQ>ww2fjp13;6TS3qY_;4S*fmk>2ss^sMo2 z5!4;f13)-_>xtfms0%g#gxaPT+lE|(0T6U+^Z|CJ4De4Uz;-^!*EETFp9H8*a$zmo zD7n;lV6t^Puiw_Ye2>U6fO0>X(y7_iE>8JW^`ae!e!mCVgZOs`t_7~;R7>;r<*A=h zNWgA(@W6Z1+vR}a5fe?&%-V_APZ6@$QL|@@%ZINK+}@TurebW8xy0{d{fhfSV^Bz! zeQM}cEllY*cIT(aJ<5g*?qR=3u#+D^7)=y}dqE2f2g||htl62Kc_oH!Q!SwP7;Um$ z@DMe9CVexy&Kj)RtlB)zB;;@;d6MR%NtoNa-h68SaZtq^<1JJV?~&kC#gOtbOa8(3 z`}N~pxG5E(uJ}HWpxXQB4=(9t~bV&bFhF;CQED3ME^d` zKNzuXX%`W+{Y+HZ>TfK@NN!DnOS+XX^aZ@mVtX;RiJWxi(F2HEI)FDQCb*rn?HHHB z+g<}_a5HB*V3UqdRgeNUO^PZJeL+fQAszSXCwwz1o zTLoJMdlI8v>A}Es>LLq3!{?pgSZ)#$sVYS@`>XJsJYnm&JiLFz&5M|0r@$g4J0M1(DI^(*>Al`8jn;Te&F~k@ItDCG{WEsLck#1uI=Q$Fu zcNg@W_MAqpt&OSewvOaz%Ga~hx6}ucoCz+6*Q&@nrnG!zv`76YCUDuk;kI!OiC7bF zhlzI=o;(>aE&W}v89($q6jJzvDBycJ@q+~pMEMG|uRZUqg!5_>B-S6Zk|H zosoHPFlGKmjn@`_mY1eF8mknqe}$>fTNrN$##IQbXcu^nQqUjsZCstNx{GUBjJcIm zlJI_0NJGAgT&HtPVBa{?4VMUnA->w58{Zh;?1o%~Uxd4GTLfl3dw62uAG6Hs)Ka)A z0wO{hR~8*l5S+rB{}==xBJ1QKxe_q$&fs;CFL(dee@h$euF73|yaq)jA_^df_UN1p zH*VisJ2U*oTSiT+RMuvwptfZ=Da1Sl(jwcUlXO0Fq^kI^B3c~>PZqJ!+`q1AAiZko z81?C|1iMfX&rrmWL`@Hr^OW%qBlk_t$ga`e7MeORW51m%t06fbM zn|uR8nH~a1wPNRM@3QDi8Fn_6T}pm)D;2qey#Nv0r2t0JH+IOpR&jdfe$)K3(v)xU_40hMVT|%dcDB|W=e@+6pg0uyVqdd;e95uB$ zwOLoE0vNC68NbItgYi+U66Yj}rI5uok7r8~3m(Y&Cj2*p>QZJqYCyIYc_H*z)RfGg z%>Ii`k|)`-Say6g<_m1Q?JCa$q20R|CNyWXqdPZ31zcPyhu`e^d|k|wWgr-N%%{`m zloRdO$BI*02GbWrWQ*L-!02Pyc#vrh8rEX#rzr4M&tp!sFu7Ahl8!Z8`zk_L*Dx>s0p_TH!U%6K=UKs{OvH8n1OJ17GIO9jb2>+Py>q*B zn=kB=Zby;1kJ0U6{{4Kw+-+M^O;G5rWc|HM*1IFAOSwxqS4y7FybH{@2)nbCqC}%) zqvVce?fIpPw0>&}>^@xcs5*q(D1Wn@piAsw@%OKcMyX+MzXGHt20t(mW?@93LaDlX z4X)66N#AhKi~*lzMoUvd{;T*}7u^ORT*~<5i>PtSm>obE8rKjpTB!PrbH;%A`*eXg z_b1Opvx2lezpkRnNxZMhub}U zAC_Z`8=xqj0MmumPGDK~KDlTeyagyAc_Rq>^ff>loEL9Tnb|~i&UOb-0TCfleA;w( zX%!&%Fm9Tg>RwWSeKzxm1{^1*YK1 zAgv*{_o*nzKVj+eWs(ZfJp1I}ZSE+yKKpl0c)6kqTusNE*tMX{YE=7{XYe`G zhK5v4sL>a~r6b-@CxQEdC$$#~=a0W>mbIflCzrzPx$U`GQ~w6Hf!o?7lA_hsvTql; z#Gv4g5j|pe)w`;EFa@$87T?aV96NdGBR;8Abc@%E%^BJ!e3Y5(NUA(zfwuExZ6DH1VVBzJyf09;AqHN_4HlJ$h&Ze zbFzOT-llcMZNbBru!)DS1O9km$<3*r64X(cx72h|)>zK`UNPJ}sD7Kn-7` zn!27K9&awHeV-!}Gu??RG;4I7KM}GMK&*}7P{V+tsN0T0JZEi~Q-^YSv@j`#~a z^1{`ImkK`uyQ}qhhJWyU`6-w3nW(y`a4-L{-(0@rr5f+3M~LGn?PkRH@#+NWRufb% zN)QW)19YDpdU~`;O@2z3$HQHt?^NR1FvWSIWD9I@62aS@R0N|oH~p5!6bgmi z3v4om1kM4Umso-!!Z7wg46uB9WI>fB9MzBKW9z{5ZVDWG^=B~sCBm#o_u7rgCE(qO zOPNMs+JFrGcceb|)M%F`sOleq$X9NFs|NfDP9W^D`_$B{Rye3`T-WA30z?bSS-6#a zC4SxEs>x?*GE}w?D01!MDdvoGFEz;3MN570C<=ScI0L_mq2?857U3wKgnzE&(k8B$ z46nYc1voEOwii|cFtA=+&J#idyT0kfx4Ui=l%^Z-Hrui3mKXqz8tN$lVTb%6vV2{QzlKDFB?ViUGj(>*!fx zGq02Vs`h|Q)`U<2Ygjd!5djI-Pivo_H6wg+Av_@@sds{J7&f=1TmxJKE*1Y-9l*qm&vk4W?&a` zOMdbSGF+o_#NjXf^Fajezo@$4silLHYb5@;Q4cq2bGN?T*wJyDPX(NDeO;U}33`4b zW;S?^fUoTzFDV8y3e)_ByFhCIof7twus>zt8t5kBR$yL8)xz1hxBu2nTwpK|Vm*TS zeDx~|crTF8M5?1S7w`L8)_-q_!y5Tk<}Cbv?xF@yhXu1S5HGT#M{7h2QGi=D?hsNs zsD^jrLtLL^9p{6t8wfzs{a977%jaMQVhCfyG9r7#I`;Gw2L5M}j$rl~;;{58yn%a& zc#_VpT;G-LagzhU8kv=%5 zDg@NcF3P8FO2&j-iI7G#M2<=s`A|0aI>lpLI@_r9i=c}j7w*&qfKKSb=&@Bh8YUO1 z#V@o01{16hxqi9+SR>VY-;JYiap{YNUTeaHuuZ3EFw-eqvOUWj#eR935`V?>khpva z5rO0v?=RlRW~D#}C36gwF%f(03L@{fbh!pze0C;dS7&nfFN<}y5gF^Lbp7uIt&n)^ zCQIcDd|SUAAh+b~2BbrHdDiCqOs+zO-adciVB-M<4Z$YEGb0xg*US1BbgEIJt+II6 ztc%(R=buD2(a8B=oXj_x&&3-#?}tbelC{F%j?rezi@?wF*=ICjN)d*!p%}rqMl4f% zCEl8POLkJ3P@T}>!`w4C!!aaUJtERCw9WUjvHA!%&mx>VJT&=b0GZ*nDy=Ll$)`j5 zxcAb1)LR@xF|i-|-f=vV_{Vipefo?h4e#JG-9-oUg-f!NX6@UV{a6X{y7&p8z&x9O ze`$FZw~>MbMkycd(O0P0S0oyiu#iCv!8K!tH!70Rx8wmID26dCJW1cHduQKK^jgk4ljEL@1)FZr8`IsFqg1rz|Pih@Ob@g+^ zfD2i&FF*DJ@tOoQvqzE2Re!rdP9ri&M&TWZ>e^_(O;xd$a3SUxqc-qY;4knjlUI#x z?m9?Lla?7*IQMdK$eyJp`0vZ-*IM|9cL3%Fon;^zYeX{fLb4B;_$;(#c-fKy#wm>d zPutt=luN}2!J+Gy*oKIHan6cEV-IQi5MMS%Ao!3U=CEO}$WNn_X^ob^cT44}CO zWYmbP9q1rQ#Vaj<*8?<0x?mI4kOJ)LmxZs_{1LVGI#CS&?c}pZ+M1=8!d;17iJ1!! zZN**4@`c4?lT!{&#b!J%9>0*IWDyFni(qjzTRV=upp}Dk?yBvuwB|I8GYImdfE-$w#ryewm7=kT2E(GRap9-U3P^J@n*zU#8z83liN_H(W3irhR7MS#(R0r z&#}_w#vBRo-2Ee*bHOdW%VyOuSK3$FZeXNe86nVG1kCQo(Z|tF%wvyRA^UgpK;!yt z)ey^2HvH|;?a?euZB0{66GO<%*rBy3!YnbM%rwv@&?W)VzNK;b6ycT#6zdQ|-dNy? zG#`4>?detfui;+zPC8DyrFCPe zNCT!VRJ4o2)Bp#Vki%(}g|*I8K3oHCPi?x@QOHS!_%zXOT>x69Y#fBCH)^}XQ{5{E zr|z;6n~Ob-gAvrNe64&WU-t|53rkU!7b3_eNg`c-rI;oPd_nlG708$6~M$pZ;lK z=*PePG%J!N9jMTiX-7MLM4Gh${>yGqF97lXQwO6wpbokdpVR}Gz?B{^#$z{zDniFJ z90#j?d`;hwG(-AZjpJX>9&3yO3Cr;fVNLPE+Q`3s+$-FoCvLx#$Bhn)@yKk=Kghm+yl%F#11)XjF=3z$gb*(0Y zbWV*>KgNr?9)B~Z4v>9{y(d24=SZ9`D#U|zCBokfZvM~(gKpLbk06{ofQaZXfjVQW zV$~Cy`mKQ>1xQ>l4S?4>v+PK@5##Zz*f79c`@}+nF8en2JrOD~wuMOI1xHvmwkV~q z6IJ8UjOY{lh`{MbpkuUJ&$lBPI6bJ+c%uSkK!hbCdJF>UIBesWAZ!kO| zP+7$+m|;b-<;Uz7GV~X8i_ZXzC=u#C^cBTXRtQ_!d0@W`H+{j|Ru$AV&Lb^C!Vwkq z^}XhaGPkt(= zD&~P1hm$qopw1q#pr6y%O;@8U;9@S&M{{;0Au1s3*iT-S>j7N<`;L8JD zgJ0Xu66}yL$V#=r3lcN=q+;L?HY=7y{UR*Fyl1SFZ~|4N@It+;{@>HYtR*= zNpP13uXihuDv_RWda-cC*>38@jn9RiLw|cXWzm}9n6){8Gu7SJT|R$G|1$JTWJ%x2 zA1V3jLSrA5{t@PWdif`%lpXkim&4(@RV6=&SpE-TeK(?N9%xl6|S6 z!xXSSaunYiQ)ym@3teAVbk2Q4{F%>N(N33?zL;q|2B^q0hE}lcJiNN2`J6w6>{T&D z=l|HJji>HVIf7FHc1O2)*H^Xx<**U`UF7>%?q{&Cb^sWe_$V?wTT~?-9;1ot&!ZM3 zs7gZ_N&JGap5%)jHaZ}jf?k`y_q*5IL+v9E<)Z}?aHTe z0=gcxhq*zUj=d|``1Kc!_JNq#a#qA(107w6@~AR6lSsT%t$ zLBcj04Llr~`o86C?cEC|K5;yJzLZwCZIe`}y@8%Sk2IGd#i8jz z;e_j98I-q&lg2iLA>~JFJCzwTJ=oj_?AD0v`b_{Wa2nC z?YBxEk!BWECgneD{?PVlfVz!9#YW{50o&{;k&hCNIm==# zqEt?ftIO?9)b>)dVaI_IyQ?D|X;>DqV?;SFTw#6TeGBT?xniM*ZRKa>okX`|i{kdL zuJcKCOy(NY0!vvZ|6n5n@n0FmbU@J^5pc{-GuheX_9xigFdJv|_rOhY)gD}*7R`hl z&pXWaqlTSaHuQFBjaVDe-|i+*GCtczh}tb$j>)0V9Z+0*d=bS{tfOD8r0c26QXhk& z*aClm2OC?**=0HBDS?0WuqriciiEd=w?nC@1?7lXYBF}3KNrNp7-?3_KF0^0<42ln zixsYc!eyUxBX(4O!*(4k^T>{SM_eN?`4MHBX_aZ^K6OwY7~(D8PAfL^y~I#+V62{M zH_B%dG~H!Q!MyW;GH~G98puL)66@LbA<@=?L~n)a7u_$qdK!G_4=e2c*ZnVV?$Xw_ z!_xvtZaeUMk2jS49`x%AYm$+^r|pBYfWC7>?&XL7lE>UM3pQVi4)wM)2q^H4;q&&S z#==)4Vsp3xhICP(9drr%*Hgj`CHrQPN^yYTbW%IV(iSYUj{rDaaoPa6_tVACPC*8n zKY#C#1iirSOCVpgBmE+^KP%??Uj*|cj3#<5Wiw?nC}d^U(Vi4Xh(w6wvg`KC*b6$e zoCm_P^Ttvq6uMeZj?`AP!gb9&pR<%>aAsqBrIt0@Ob%^mIAW+xnE!ZerO(xhUTHbY z1>u+T*X2FrJ#?=JnsA4e<<>vd2*vfHp)Fx35q3x}3mgTh^8T{3nBiCWqx1MCsfy7+ zt%*Y6AG6@mK$i3N6ip6Ae0TQ%;HUHctaLL)D?th6}`;~zeiXlh*IbD?n= zL1xjGsCHeC$OG6r5y18WP%Uuz#i1|o3yE_x`Y~LaM2Xnr;?WJye=UJHxK&VHdOMY_ z+QF}}0E|dhpfW&8$o&HdQvC18)S1*fZ7&hE+di_NiV= z-MRB0G&4%^H00xn+btDNk4n7t@wN0g-<#btthmWHJ}F4>gwnN?AU`%lFMpERAcJiP$_g{7J%Qf$E5TQ z7t$}f#u?Jg6*|QRZ4z>{x!&#^4=*4iI-o7$Hw4QTki^;Xppi`Tl-lBi`|{7VwX9Yp zt_guX0$2vB2CD{H!_U_N#6#^#2HnJav2Nv5E*hJ~+wUU92?N<)$e`olb*X#??4i-3 z1R&;s@XN6wah5;=g%0%^cUDbH9ZQ`ZiR;t-m5E`hPBs9l-Mq0{4J>C_@wu?DINk(wUuT18cKuDQ59zj=D%3 z;+pyn-1`-~Gp&@lOY#~P!%P3Xm^mD_Y7she%X7-fv@jA{Qej0&Z*oNP<;MxUosk%w z8p#G<%i_SjY^yZwqxvYWL(k`;5AD+MK1Ql|cVJb_(Oi8}HJC4~K-g2a_ap#!n@3Pd zStA=GAe=8efc<2}l8=uxBaWI&7(j~Fg#U$U9*(vBtuZ>b{+-hb*dwqM-1sv4Xh6Lz zzAWxXeNXfB=H&**SNPg<-@nvLsl)y-F4(Gu7gV(%o;x^8Z$SEr(ZashnF%5oA`2+J zJx)iNxCJ059RwVUVRDF})V1px`;pM<(CP@dscG&mnEC;Dq+7Nn^wd zv>ClhGwrbIu=3Ai2osa3jxi+6hRfrZc3NEO2KMfo6F#JE8RwF=+G)1xC9{1|RHF}x zQT?9grg~sv4fi9p=YkRQ^)r4VQP16C;iqG!lFVP%eS{o`JzAU0E(AlQM|an)pOi%4 z4pfY6FJI?sUa7)s+03uOnNs&_{xhs7Ay?FlFd=hlO1xT(whK#-{`Xh})*Y%UopufG zzjMqg!zdy~&bYua+tRZgdUsYgUt?Lgst3;9eOK`@bX0;)Ku_Vza$6oNqn&rM^Xn$%hG4zFODi>F*dtJFo926B_phjGV96CqlKr zQV&x*Dk(V_MmhVBGILYwsgnH|LdERc?I~Br|KJ!?RXOt3B~PL>k^T@=CoZyVNHVgr z01#g(pawFt1clxBc=Ts&^a?C-L|J^buira&LIrg^-`%b)Q8I55Tto}dR?8dy_)X8+ z%`KdfHTuug&mNFrB}AG)0tk6BdSMG>AW(l(_=s56vB`9i+Z1AP8!ekQ(ESU&6FbT7VJX_&=5zMWY>3k*BI zlT*i+!B>@!u9ZRj&?A8ZpHGC6kDwNdK!Et>4I%+;X%JjKm7wR;iq;CjF4LXNI7UY^$>df@aqRWJXAuCGOXZjyiqxVd|)$TUsl>mRmvq z{SsXW&{edv3%Loq3FB2OQ3|MGg<}pjd`~!>(r|q*Fp!8LPl<+OP}Z^KI87nA7Hpqu zpW7B;XJ{nm{JQzl+kqvbA*vy&a&QHqIKREQz4OK#8Z4^2x$5KT>InZEC)WngVm0^A*8-4SCUK0zSyn=RejN1BmDb2;Fr@huA7dvzJrCam)$wqNAkN3HSD8zm@dcb!8N9_|-y2{KofoX}-Mp)^DxfQU?7R8x~{l&;c#R zh0iC=C)p@Q`Vl^`{ld&YlUa*mn>;(BABAZrG5l-v*NC-yW&{Ac+_=)XQnsEFaDXj& z9kWk3fld7=eI2pS``@B$AolT(Tlu95;_optk9cho_u(dFS~XKP@ViuQiJVv?FIItb zM64f{QBIKn-0LsX&t;$*xZj3nAxENfpi@!(@+a=!3_y*LeF)1!@^N~;=tgmneYkyi z1MFs0ha*=}FwoBiSgDeLQc!e$b)Hu6;s}4^H!z zrysjacB}|-6})WcH>Yb&3Y|?Z*0fU?=%38pu48mh#`fiR?S>z2rl`m5blRfx?hJQLb{U-YQnmxg ziU)t1t<>oL&HUfv&$lNj%L(!PJ1p&gq)mO5YV;`8kxDR>eQ+-SK5Y1*t0$CDs8qlm zgiaxsD1}aEl?hLoB?@zUSvitj-tC-K__9wgYS^n((Wtsvk7n_DNqPo&2Hfu891|WB z>LTBAfrtYlDWfT)oq}x|Z5sF4c6>;4%2OF`oiUS65Vjn*91C(N$etp<)A|RSrM9EG z=Z1cQgVg%#ilE#I1Gp6~s0mrdC_(R;pZ$ z)TD&=VRX!bfdX{e%8#4qP*mFNP@jLE6rMz5nuX3w_z=mqOs~NrWd>)%XFkQ)-i&oH zcdjXCofh5+>{<0*OMN^%;8;hu%zHnL;r;`GqbyD967eC#FW7Zc$;Ym4Yvp8}^w~0S zf%5pPr*s>&ZVgn>MLpn(j+*hmuUEBi4PvT*4s*sA)u%kg_WVY;k?%hnEdGR!4nboG zaQ$z2H%VMDqsIBNqV+nBv#wsjsn3Cx*Xow+I&0RCM^NLs4HP znn@O2V$OD`e+!Y0Lu8ybF;D+WY#9p~*>^anq^G2v zSPG!zTV@B$4=MzrTG#xH-c9QZA$#j1Ro0H8+*ry<*^Hvpn#(5><~X**wtCvc3T?@r zF@0T*=FN3W`}2kjGaOnP1}lpq0ff=t=QSu%Zg|FLP-72eJqjoydClVHOBocnyS@7X z$UqvRm|G6p{2|=Ze4m&mECjDSh*x!0^f{Q{JG6+gSc5R>VcW(*dx_98+Zb6(p!y?u z7rTAm0^0NMHr4Ooa9VZ#rur;OwYa$jMMo;+-|4{pu-)Llo1_x)pCuCb^N60XJ9s$# zwDT8_L#vq`f*|f`mFgTrabi2mxuNQ0Ou=e0op?o!uUC@QKPz^a&qpr-VX;`m%_p z;Z=*k58AyKcltZ%E!NOqf}y}MSiVgEzb!8@{6m3@THgeB+S&H@{vCN@^+cD2zBYGY z6TtHAt$PLiRxFALkqPx@otwnmnb0&jLuZl9d}H0?q#trm*K-=ZLXc5XHt7`HGP7(a zhMfj|s#FG>hMI;-P!5o0^NZBrZr=@^Y28rVZ~UbcdwM}Q_H~%EZxf4f)5&hTJT}33 z;eN6{(5ywP`g2dH&+M-1^N{2Z1HOCdxa*GBUo=L3QFvrIkRud$>A7Htp9_f(^n9w{ zQn%@BdRW}OqP}_@IpY3E-#%@01jy)~w>{=*Vo)bWuVHM@uceVGhYFh8@c`b#9jqGD zW~@S-S^$EyaS9~KJZM-LLLB>DR05)>*T1K>aPx@cH5WP2J=)(uON_5)<3M8w>%GG5 zf6%HD*{k4ep2&x>vw{L={j=tFo12ns{IFf!Ex1dR>T%-EKT;^bO{ zM2rWfTQVrYBJ5+sQ@&89F6F&#}+3qSD-Y6f@bX zn2l)=JSxg>3AF@<{4I`Lfv`?d%{>_e&j!*n^ngNolLXb1{ZYv1nBkvXh>W?^W(q z5Gat=`~dEw#{w|fDk3?*BaS4cgzjI?pEoj)Uz(qtAS>$+D_3pSGy_XJCzBFcF`->_ zMw2_i3jWMDWz*#93K|L;j;e7#j*!mz09g?xLNAjSDOC#k-iMr#Y;kOH%1Cb6f@4ou zBPIazu1{8%_&YAAJ0m;Maq7L0#?1h&Z?K2Qd;i875f)KFOx6|$9B2`es1>%n;*fRPuWowbe^S6VSNHLbK4>|o}MO&Uv5c?ASA-o+q7OtSnCXa*&R0g-} zgKuG}mloA!d>h?7)5%C0{E+#Od4YF-db@HmjJO5A1z$jiAdD=`Kqo!BqnBd6BemT; z;PkBi17bi)ayycYxvVCiZTv^}rFN~xG5(Q4WKKd3p%V}>&suIzbv>6Dmlg`5GDDf0^k9YBoPTrk0!e-CL+C2aE+z#2jxPCrP zfu$-;fm^hcu9lx=7n{EV5T;0y!E`LBXQla5Bf%!_eFQ1_E$2_D&Z<&I_3r} zpbY1Q`bqkpiLtHi`1IEX4mmM7F>9C&@DaaBwM*rgnbAnEmFo#HY&T*z0wM|B@a}zs zvPRU&`SeZ(h!m4C2+eZZTjGBq-LsEOJP&$he>HjGOI%>A2buu}){?+XYlw|CHU9o5 z6sm5rqr{EzQjIS&k2*&%#1pYLyO2af!4}ucn)TQD*E+Bm?OK|j_2g9Ilfk7EQ%Q2q zlu_y5K;v2XL@j9LL19Qqc}e+ERZp|{ImX6SRyP^VvW#90=Vzyp_o>`vsazG6K%~QE2i70<^az6Mmo&B z!A_Kg+a&<0b9Vq)D#esJNvqQ#hFMc;Tz%lQ4D1HE>SxAknfIYuzAV z*y(}Vm>qD2n~;Yu+^gIoBgpk5ZKRNlgOPvG^H6l}kYU7&b~pjB z|2HX78A(w0&eY)-pI!#;>f(hq6pj-)0CSevKDiO?7&_i16otdHQX*)(utQPNTEoVG z_WYwdkR*sMVR-9OfCI>tQpZ=X!|#!*Q+@x*Z~S6zv!>T%>Qg?OzV8j5;Xp?sh?+1O z4GNb;x&Qs_(=-4d8l}NZBiZ6kgr+QAX#QuI@H@V`9IMfM#(h^oOg@0B(aCOYx>L2$ zVWvrINeWVMlF%fMrt<}C1|e9=>m7e9ZGaKF%{plC9X!MCi4e_Xnm>7PI!n6Ypn7RH zSV0#kAvqUP9d4bJA|cP*6W<%(ixnC>R4P)%fC-|4F7#!idcwB_A7ffBSS}PP=9c=a zLGrOTwhb88gdVubPFx!LCs?QWNivF@l4uq+ zpBZW+=B1CL77N8H+c}R97oWUKx8jEQpB85dnxFWlI0di*IS=&CiiG z_(`S+d@Uo7qMs*Xn4Z^gAc^1T!oGtc-d{kI{Z=KWgs!1Oc_`&GY18M>l12b8E#@bZ zR34m3m7*L4aYWwcxn*NF;c2C^40V1)<{}-1nk1}hZYWdo1}uH#?v;s^34cM0w}7uy zfqE~$p62o{H-})epI`-sfD49~hNxws(A3 zU)){XO^;0%q7wZ)Jod1G4@WS%mpS+H-tT;Xw$q)dkppf^ z%87LSwL0LS?(X(SQQZio9_}@w2i2AEzBPKWc7ah6KSd3XrTy<`Rh2^Ka1nC9j}7Q= zsbqw|l8b_V(>j&B6hFV8%JDEe>tBz-p&+9mYbO0=2GGwjw;P&|S8}pkN%OQ42}WNv zygl~eMH$5y#pncG!+QrTQ^2z#8)3Df%Ei(M#b3VlaQAliz7gxMCz-P}C>W3V-sRB; zh&WGd;8YmQi3@fdm;!w!X|o%v8Cg`nM-!N)gD-Cqj`Mw z{OZ|ofb>q=J9Y`X|0jUigq#P9%s7y}i`e86`9l6e{zthUku-*ZA%JAw0l2MPberLB(S_%S|>0C_j<@CP;Y&WnuveNh_Xb~#Og#a{akp>>juAnkweMI z?93XRg(YOjfiWiH_k8Cnlj~t{*0k>3wR7d^>+s~m;$PprXkstQo|^tb_K*%X=X>}g zvgpTjY=!k>vUxnSyWkq$`Pj-iwn=6wflaL8q#6(~I1kXNB3p<#lpg**c)^nj^vZ5K zu&I3iIm(IC$qqAnl(vUupqh5htI)PnQXxHfKX@+?YC4i5#$L*f4_rXP08QH zbl>*fN-4r^1Uvs~N_SC*0Yg7|q*W10(a8OrMziqV1?_5FlWGNF8jICSNY@bWxMdZ6 zNuPq%V@(sF47j%&*vwuML55cXD}njCe)=%3B0YFMc#;GSo(-NAA^yYuMHTG+|K$!3 z_!q46=#P%~tCuer9WcO7PLs5A%=!qVjk}H8hthN@M`V>Dfu) z@KPZ#DbL5H@|zILdjmg$+nCi}aSgA%w`{NVCH=Wb6P0kQr!fX)`<`b%&-L&q@!v6O zpD-m|Ze;y=+ObSJXIx&>+tj1^8t{H5VV@5rAQqkqu>Qz#u~KjZA6$xW0swEm{m|%3WiZE(oG;6bNvRI9#^rJO z;Pf+V%d;m&+47;K`!9s#<9%6ucu#6;v2b_vU}f7DWG3!4$T*Ap>3re+RhmAd9)Mp135HM zT>7D~cqQ8J;+eTzKe*m48Go0Bfh?Ye@005NC)WXvIhR|LDGIzra%#IWD1La)g`b&v zmHU+YX8rA`_2-Z3(wHFI;e67(Y=WT!^fSLhc9L!a*{LLLC-jz(UURFfk)lhaHQy0L z#{#5GxVT73HM=~1dHhPv6LR6-7iX6^!7ENztp|G1?^GGyCSA>unix77I$llt|6>oo zioS|ARPjVpb8-VXzM(SR`hIhrCrJzGOVHj%R48Q9Re^QtZduQ(vQdA!l5ivwTRSV%U3Wq zGuGh_JJ7f09uwrt8YPa1UpZ1g(7gs5tszo(zi!33zG?ajKn}91 zv#M(i$PGjyU5%*2|q69!6$6)WI#6W&`E7 zG{63f??Rzh0E=K|Ybw&AT!QLRwA zC%>u5GBFxO(M<3(X#IKO;no=Ov!;*F4#a&n7OcaM+zj^TKltTo%viWk7%v}b^!^S0 zRm-<$KZ_K>6(HeJ9b)$%89J2onJS59s0p=Zz&v(H55vC0_QLQ$J?;^9{xI}CcTy;NY;V_5%L!pr!JlijT^S=($%*iil&3+1<`)^ z@2)G$cDz1&3bzYnV*H=+f4uPC@j^o#Vx0Lf@ave0E%*G%!pQ!xaj0Ws|>3QC*ft!X*}aeCDx9+mIF}N#;f88 zCUE0}UOUK4fB3&gZ%XmrLPpD}V$GS1Ms%XOiKy-Z3qtr0>gz}(WhPYX#6fj;U8aN= zHi6cJA8|jfV@qsU$Nc2JCobdH%Jg9RsCFXT-t+h0+7>da$UL09Wy)`sG>i%=1CgdI zq}pWN5j*%VLakYb3g5FK1Cb+TK5&rUv zKI6&0A(h!uJuBUgsv5YYa|w6E%Ld~BqbCn=`kvuazo#I(ly82W;(Y22s(1Ihdb z#B9yr{wdVzufqOUcnMvq4+IKQVCE+hthXP2z10WnCv(gZB)Pp40r!eIL&>NA;Q_}a z%ivxFb}^RONp05fckAJ|gh^w1CH|j0$;;vha4|(Q2(0=UYBY&vxdP$(qj$zqiO^G?$xM}v zPJ8!r?{n{B!K7CCKa-m(ZyiT}pomppy{p7jv)V{)FSXhYI$Ktzt4l_IpfOu~`30pD z2S#mxVUeepn1*9bVNKEe=CBmNm$F3lgSc-Ms@6gToopOM`-CSzZU1HQaM~^IPG{Rp zS42$uNm75h@Yb+F)B-_<8KV*nfAR zY8yZCoj%YIk3?HYYcmHtX|UHs4=oCu<-t~YK@__XI(n0+&rg((i034C(HVvN%yw1T zb=jNNIKuz%!o+|Pt6prACG#a3m}XbDtn^IZPt~V?qWBPFf=}Xj&J;EfGEK^sGK4wf ziq78}r-v7Z7Z`}f-zo=pkd2j$mHe1bf1m$8H~06A@{L-?Gv{4Uf?*f{BN#Gr9fkhR zvmb3UX2Bb)+<2}8y{nO(1bzp&{UaZ2leweLKi|1j$`AZlkSi!HV!M55A?WR_czMz8 zgAMZWW?uYh&bXi5b0?=uzIIAZ*ref;({B|-b*Uo%fPCP3k1}YrReP>$7&|)SYi+?? z;42T_JfZpEa+pI=7i6Mc1DwHjIsDgHrN4{6*xH@-I*|VfyXOY?D&UaTd&sEhPhty= z|HqwDb?nDRP!+jcG7Q}Nu*lYuOc z*6FSYY{Rm(U2~1%9V`@x&|@1+Of4P9rae{6tIYqEoF#1JAI>Tj0Q-95mB}&tO{zD< z%6@DyqyCSHc90?F7qL>I^6R=q@TfAc!15s%0uK^^&dBId5fI07^r+}~`?I?Q*nmnA z_p$P^YD4ec9@rkBQVl6T!|(|83iT3}DUi&ZG*ZP>O-R9C!?4;6gPbJXoPCF1zlDcC zfIkStmbjn4tlm2juTQjLm~jsRnj+*%t{wF9(`+`V+dj0Fnd9Oc>-tzYOVE2XuWbcZ zCM{Tr+0%REuYC*LTC^?2!#7m@EHwe&+xMvq5mn@C8{8O6 z5F#->!`hw#jOE*H*RiR4^spVtO67H4`yjg`5TPsa}OG>txXKOJLt4kD#Lqo+wTl{tUJtZS3o>id( zgIP6xd{P8rM9%uPRTDHI%*GLo(SuoL)jkhjmlGn0wA4-E1K#EZd~$Mhcf3gqJo#_6 zXT|&!Xccj1g`e}8^U-!3{j)3EEZ4?8lWwCe1%hR&PJaR;n)n8%ceN(b++;Us8+biw zgBe~XI*s3a^7cpefa|4Ums5nFP_Dx}V!3nQxnX+tTh2*(d87h;BItC_AIA#%k3C8^ z+O(rh`A$rS(kM3|^IT`;MW24>W!LvE)`$R3mO2ulvd-_Y&T^8T9 zPK1>^K*K#O8!jybpdxyme<-Khx7IrAUVh>k{*3>`a395^06RXBV1HVD=)7@6y1>4` z)@DLs#b(9k^NvXDhV(~P_g@VsK!homL|Xl>AJG`D)b`C9!#OwhrO!$RKdwE62zIPE~Z+0YuNZ{c`wNr)zTDWUk{d|kD*8TGCA>CM{7 z@X~xclBC~+@e&GAMYGdrh%JPl7N853|E`MYMYh~EgRr2(lbj@$7{TF8Zh#EnX%er9 zJNSrJG%5)y07{M4=W^7XI;Udii28~?mKCUTcfF>&Tty+R)llDcZz3loP~UBDepl}Z z-mC$*Yw+v2u+Xe#`}mz(%2Isee_PH>6RSv>_K29DSdduIhBhQZ^Ah(+l3%A{oxMb& zMwHJY`-G;}TKGlDu!2&Ao1*Pq+dChspaYgULrd@J4xiFaMr#QU}^qgLsi3OW*|~bT&a(3D<9S=JhMGE z7kD5)mvpv_2CX4HsH+iV<4q?URp|;Re)A4|2)+hAWFUDc8|1YaT2*j5`Y+bnj#oSh za&do8S28@6ITEpXai-8&E_0Ywf@(AtIZXT){!ISFcVBx==#3Ix2~bK@co-%tt05Or(!X!o=t_%wGItm-(qySlrIU|oOlZhfM4 zO6@t9$>Ge5VCpC6WQa&3M(-Ef$eGV4bpwUl_SLV$SH&mgF@zuVy5(WLcHl@W^c@mX z6{EJWBSohGn2VtC?}kTY2$@(v><1ju2rLk(VqB&}91|Lc`XR~@>ix=9;4fXUB$p|# z1?h%w2VyI49joVnZahbT*!VMQ!$-|r_J;(@>AH1Fhpgh%y=vH=clNY;=tp?TLszAx{uVDrA8Z-4o;S5i)3 zF2BwE^^^$fbo}GCZEF(SAoDk=yQ8P0M;Q4!3E*m?-(cbX2P1r-i^qNnMt&G`E$xkt zRz#1u$^uYX^Zb30x+9V3uBbF>@*U;uVdG|iO4Jjr1MygYxv?coVz@sshT%KJSNp!= za)f#yWn+XTAR~s4%(XKlW6srRd;z)H)n#W>2rDV8^wOXJx2Uc1ykmG(bTQl7udoyQ zwV*!0y*tBHnf>0T&v43?=y(o&2*f7k9?)I$O92VtX-~zEd!ESEU!XZbKrX+D5AMZ}H+JrYVXpH% z_va2R1jfuibjV%zQJuF@yOV4Zs2(^0wY{Q7Uy=+h<`AGj9~fsAf|I5yiRy&QS|_G|eT==GM4EsI zXr043tqJ2b2zInm42V_f#h~XibZOb-$~g3{IT`AJh@@nXjOSiT?nO-E*#uhpl&Q@c zv@)>P4Y!kJB(j7B?kVoNk$!FNH!!O}@@{TlGQ#R>Bw95R)cAgAADjW=1G^w~TNI}h z7$sw5&V4cZ>&aY~x?pMJl~ zb)t^E52?;fnT?j~Rrm0UiGhQGgCNFbPM8nsrkE#=K4*_!ZmOyFLC7uRaH%adb?CEte3nUc6lBMgd1)*L!m!i57^!BQYd3Em+JD~UC zd-U{wbsDM#4@YYnsriNZg(pdeu~I0$a)so`*P5^%Xr#D2czg-F^}qF>zltO= zF^)Ag*8pA6UC_A_dmwuudpU-5T?HI~dBybR>ME?~B!*vS3`E54srLNxse%t#77S}D z1D5`}IF3-jC;ioSFm4vgKT%r!-a*v6weI4~m*}f~ZMZ;K4*DwY?z60nmGky%Y<&-r9|YGbzZ=L54Dgbn{%FXz8&Ad5O{=j12tD8^QCA8cOPXt zFGnop85#9KNyQ)bndIoS;p&T|-0(xVvAIc3^We(EJ1W;{Xo6mhHq_pv7JcF|IxE=? z(3n6kdF-DeE4uLh`gv?&jT=v%B{^!#H1TGUj3!lGxh3@CqR}I&@iTQhijiDJ>@iA9Sl)6yc+W1KUDNy!fGiy>Th40)ynXhlJ1H;Ko(zCzxRr***#(< zTtblfP|hXpavyPKZbb@3I`!*F9OQnfLxric<5YHkJ@8a<9w`c_6CJzy%PE@TqRBQz zpKECLb0k-{G;m4IK5Q}2Y-PEQU6gyoJ$Yxh*0Kt8)n2>+`(TAB zj}!ywd2ip1f$|yCEt1vbNy2@;v6ke(^`z^`UsBkdvQup)oy#xCsowzuw380j+K9Rm zvvG8(4pa7_ka}sGnCW!rPvcCO8mDOtTl;-FPm%e+o&A} z$&lQW1x7MaffcHS1LvZu1A5uBfjpUTS*(vOdb@c%?V#vwkp1FZ1zhW!ZPcfdQ~ciqP0#^Wbp zCLf8F)4|Vg0E;-cbf-!t;9KN-36GahK5!DC2qP(I! z%QlH9|5l7Mx6oR8B&B2`C1GaMSQzC?v7yblI^Ec8t;uMErM{erpN*f5NNE9saq*R{ zA4Xk4xd(VAt^?ULpI8oyEnEyAeB&w-Qq;di$+k~+6_bwhAavbofK`)ZM{8S*WONPh zXzyr0j)i0WR!IYiPfR%un?6TeI7nX8=R-9!QWm-(Q7V|3ut8^jU5VaabFrk3AoT=r zu@)u(Yub2Vaq=496SBGv@NNLSp?OJtG&@%Yy4(Wie*tX0))(<4-Bb;y*G>vL2yQO? zG@7(B1O@zcfB+BGu|Y=1HF6akLlJrX#Yv>Sc$PhJ_C8@rg4qqOKZ|Gt_tn_Z>irBG z2)DxLzMDtjZc#QIa=4EAj{4`LHN9=UZ5vQt$}Vk74${Y~0BsK`F0it*e6N^!q#`@o zZB%D3uPDdRTg0Xyfne>Ep8{P)w$lWdV$paT(ZwxB9t!L~qKT4vq0!Td5TbCP+TF=o z^w`s)n0l_*b>U;~O{@7Rq|+dCyym;*EDUsxd>7=Spfn34J4yUv z2m`ABaSL>%JB~K4z?F6}hQAad7ysxkvD0iAlXz^ob#ty%*0uuyt!}K>h=$lR;5#7m zsv{`=_Xn_6btG-kpQt^P70VUN=$XkaQ%s#o@Q?b5#ZO2TxfQwFS0+AYK4#A-$6-s@ z&Drpc<43M@aI2oHo_>XvanFbWeE=z(k8eJ{A%^Qf_QAe2_FpsXZiVNhP9;=CmxdfY z)!j@9ht~O8KTJ}FO*^V}%C+Kgq+4()u=+>ulgw~>N%VI`2c%sj_OcNpX{%_fq!j$V zEGMhiy@0Qxtfq|EVTjPTYd^QFu?j3>I#^`teja+3!>3pGeTUw6Sy?(hM`0r9An2fo z^beQiTRxoDH6uf=s@z-@<(2CjG44h0E8lk9B%8lvh`USCHfy#&6idc;AIzhXdf(FH z?FHN)sH5rdv@kL>`)FrgtRoDr)HJr~-2}BlG3Krz%8?1CoG22+>nfTzLsrn=jooW$ z+iBZpqD}@*29t=Re=-n&MNHHa`|HprIhIQ*IURD)SsH*L+^Uz;w82tzcIM$s!KAVF z@4``C^D|rDY3;x_lWhSt8!O0~2M>{&>_6Iv?HA@;!Ize2Gi@p9WLFq}!bs#^JXSyt ziMaq6G9bCk$4jwhOHis4B0tndxw&!feCJ`>Wgpu(@OPu0_mg{-Z^QU?fRB+dYqpB4 z@fHrBBv$ScUYo(0)Pfh{eW20tE$=A%ll49p&hJ#l8XqXpHmI9LTy-q z!h0PZHcg~vEUS-lMhEaTvCvq*ann$0rg!8|h;u^24O{OMcX?L5!qgfi*Ru2KR^dheqZ! z$vY>R;)#0$26E@s4;d=pX*m@v32y@8f68Yu?qSpF0xBhd&DS@>L8ptSi<4H6d#lUw zPcm_iBaK^(Ni18W==^p8)5*om>iS|UO>NGeVnzIA`&A_p)Q;{e$88jG&j$Cdd*fm` zR)F`foxC3XG(3T+tlLqZ_03NNab61h%*Bo3Fb9BA(X;H8Oo<56>jm!oIjJ-#ESEIE zgMwaHvxZTFLY{@G`9mVeB4L;=X$JIKDvL$WSpNyTpUW)WS?}Gyohz@!%2YVX?yJ%R z?K!&9kIbMG!1#YoFWb+f+;R$-6ejdJX1(v>Zd_Pv{nazpGtw0!S}&!|b0|;s@u4jt zFUHc}rcxiR^1TSs6bV3I{Tw$+Z#@V=AFP7rjNHEtkO24j%!kp@f$&z%4tYsI^|0Kxj8VgR9H?D8Zf7kX6iHdv1uXfjG+8OPnvaYyMB!~S z;X=VH4Gr8R$%5VoRZ8K1Y~>mAh66oH3RM=a3kEzt1+zLHOC{dGCIRQTdv#_N^TBjn zV(jL6ImAera&R_Y#$SpKO(Rp^7Uul6B~o)(*~LKFOe+~GIU=7t8Z}4iE(U9$k^8q4n*>lW<4(_ymj^Q-Bxh{hX8o+t!%6dy(oA@(zYn&U zsMP;lT%Ix4;DO$h55i5cVRGgmTdF2bU$f1#F0d|C1|9?hKEb~z4a*M8>LJjIq&ym& zqO{tG6fr%t^}&h{b#1ZvB?GkvEU9_fRpi0< za(pDU<$ms|9cl!fLV)D^I*x2RU@<+D&e19~K$|+2>Mi zr-Qm?0akJAN@sM~lf^;q`+w5JeU-`oWcS>7QLTo;k2TPvB4s8b#C=y~_}va&$@s|) z*FYr6JE3%Y$tR57YXo!_6->=G_&YCsba*TTRX>RN&(=R<-&$?qz6rih$WgmXsEBz8GZvtd;)$f8jJ^@t5xQzKE(hj^(v z#JegV9axdbfOn$CSQgSGQ~MX+Ov)x`CRIa$`V-85EpIK)M+}XkBF> z`|AnF`&;|qJ>~k`KxHg1oNXj`A7uej`z$7uzwEP)HTM4ozw>tf{VGKNKIZ5jn1slL zo-8r(Bz0r_sETb+88RsIE%t4tgq^va`5{)gN(>G z+5jfFcgwQ8CH@mjpB%WrH_CwVwGMzV_OTJ*Y^{C7JEf5o;kQ2teb8s)7S{GR=FPQB zx|I@NMFz4{KqT1~KFK5@q6wl2T|#TZ2f_y>1riCz$a4sD2=1Iozjjwj)z$5tL^fdk z_4rG^fIE|&dA@68=)KXNcY)*X^NzMgWFab$lHDa?@|lCbn&dahHpT^FpQH;&aCBsKOm*?&&nMjY0Sc zPwdnF=2Ru@H~UX(ALW}bY8Q#5a3r-SG(S&V-MsfFYkZ{GgyR!s(Ev;G$tr|af;zq=df1a-q48fnhfp8ppj|l_T@PU`Z98FJWKU_(?xJ{AxtH@IX;+e zG5)`ye_!nAAN{I7*v@Q$S-sp$q-$L72qAU#=!@N_1#AWr)Cg=mY$O zUL8*dw0dBhM&sQ}Fwfp2sXS|<5q&$Vc&kKfPY~p@#qMzYJ&qUSrN$5e^xSi3CwCFY zhR{Z967*{TKntBL%2$oUSnC2eQ2Af8Lh*5{FCq>{4onucMS zI8J&i=$K(#9kaFmq(dSdJ%Yu|a7mJ8$YiNPCCd@U_IrSyY$x4Q`sD${cr(fek1@7X zu;ScFc2sUuPD!o|ydcXHPxrqxQX4E#KeFX5 zVv=-?IKlj{%Gug)*cD$ZzFHcd3h(;#U?WA!naROQp#2ICpG^7-`KbL912IF@`-J3 zqmBCBsW+pNoD%0qzx%lDP#v!>8U^cBEmmOj)!j{;&I#6|V6g&k|Bo$7kQYd)&U;rfiok+5fM^ zHZ)C{r!}#fC%LA@%zH`!5a~RW`OXSgsr>zUG-V=lR74?FFubL9d`C-(7aK7EHR2MI zV=KDs*2DVEhn&^3fi1jnT4T-XK%c1!p{wfF5cfRTlSL;_t-Z;qI3k8<-=iGW@ zH24X9=4Yv}torU6=D+e`I$~uI%fN}@PZkE?=OBPF^jgsS}_od7A=cYz9#0 zcIL$rGx=olY0c5;?TzGd1cS}Gy-fFONi6o>xV7h7{0+tLoc3dzJ&yeVH;AY2`F;LX z-0X*P-Nnj3r{+Bgn5)Ptv?{dYaI%e)<(I^p<73&GFL}x_x>(nO-dRuS@&rsvD6d(A zzN}3~F72CMBx-~|KPc_J!U2Dt1kZ|X%roM%(z=nr#`x_`#WVEV4}swWX*?wg@ARtBc`^R-!TMEnig(C zjW?3>qP-=jVV2X2ucHW@0myW{DSgQrsI9FZRaeZ^MtXgsU`E%w4%jZ_#G6SnLV-Pgrv&u~TH zDE8=KT3t*7^&~JbrlMeeyAi4NkfKm~Ww59q3nh^dm*{<5Jks!T7jb|1Y~;|861`|M zVo5GWo|=!acGiFAq-$CZ^{SX@SMe28g#LmM>_PM*Xkr@u_AXb|!QZPR1EDUyA2gdC zR=77}Ggz7e8b@$f(sN{njyxLP6^pJj=>Im?5`t8)f_J|HSn270LG9Cxh;B2+7s`xx zZXmY9={1YAH`Y=YvoD{}Y@|+FMeY(rwkF+X zSu{4jRpf^whylIzKf+3CKmH&!J!2aj*|az(h-)0yZx&}qin-W#jnlPx8a}|sOG$%J z#bXa$LB2#S8llFC{{vvQX1!^>S&TgdPC%v;L0rhT^2;(4 zEf8Q_R^4+RBxru?h>)MDB9OiErmb-95)=A>=A2~XFf(`K=O#258DIw?o2THGII-!g ztCA^+DqjMNP_U);-eif5V3U8~z8rfvWa2@Mi-kGyJ_^a?SY=!I~I6UX)Lw zFaizAhSAGy!f>W~xz5@uO0z`Ms{M*iM)v5tyxGGoOw)8C&qJg3-HgZxW~a5-OX+8J zF6nTXr4+P+o|>Qd{stV`r3gU(F|~_o;LSvr?B5*S+4v5fa3ze$4V34SXsNCKq}o4u z(rbADl~9X>p5u@sx`bv>KLqGEg*>RpdWq~k<+oBd@ip;T!{HMGgwbd10XQ0Z$Eq6l zH|`Ld2)#VI5~|E_j^!2fFY%e??*pFl0H)$KTe2M)0Xa)FyhBPUhkjT++s1P*(WQBJ zt*$KmJNcXt7n-0kzJtf5Z>0P?HD(KS+Q&)W+$%ZbZ%E)5RKFxrFld`6GR?x)kYSKq z4CnP~iZw;-_+e0eq++!n$Dey(Z;4S}nq!CtuQwB@39(v_arS3?t$ru&xr7Np%kH-7o_^Ckxb^e*{&wQ?TD*}v&IN^*|K zd>U95ZId~Zs;b?4$UeUZOxxqtYS8KPWLc2;)W?8l=(^5#mIG_IRV^mdrMK~5C;kyL z(S~vT*}J7(9i)G~0g)M*_&t+=e^hTWEylir#e{@7;Qw@(0#BQJuc%O(C0$Va7;Ktc zE}>eo1BcA_X&k{etiFdd^jzbf(C$BUfk63*edOaJfqfWeyfR&;q76#Ns!ylqgXnNA z!+2o_dNq@ocE51gYevYtqCLDH+Pc+-)ka}f>P*mW7eLlN^dsqd!bXCbD|LfFgFpv3 zFX%_myA*4N6@HXPj7E$r|4Ge)Qu*(q`DXcM3(9c`TjqRdZEo#u?R#-`Y}Wrx3an88 z+A)*(U9b*qzHqm4%nKZ4USqA%0oxa{d?_w01vn+Ex=&;KW;xrD=}a~(A;0(1rZ}no zSks({KMvf+o&g0ue1d#-V!Mlf>T^Fz@<{PW&HA_hG5TZ(T6aC;;|*kAPIb_bDG+|l zYbW~>#6F&CRfl*ovXUaiayolHd#(Y#ak+6BXI<0V)%&D15fY3&--To}gM4nTA@LE> zV#Pi;mC+f$?=!8g+AC2UxzC}JO9wVuwfxn_#H#OXB)d<^U_B~tpX9&)Aft%Jl164*B({&{F*)S< zLe|RasmpARz5s7p*>4onj#j`Vubo)o54`}mqKFW|SRTnG&)<4}6ATw3@@Bav|KGcV zJiOWLI8}eZT?F)npf%Ev_Uv(_9lMY-bFaktO?h{!sUka&qml)nY%+H1+=po@m?8)I zB>@N!p2YnAV0SybS`2c0-_+6y080SX!^7C3&QVQLOYr?4%#zs;;sd&PeR_D)tM5=> z_Y1G_!^a~5d4f;9sGUx~fAw*(D=C7%G1o{nSQ7dmMO$+HkYg*m+)>5)#5YO3<1aX@ z`ZYf8Gk@{>F)tT?VJo30Z_L^r;x>(adDHfhT$iFYFgHns9N(JdHTy&AvS!OqcJeYS zfbPAUF{nZsKo6^g&E9pU#rsKL)BWoO36=I8ONFyr9qsA3{@nNO(uK1Ely<;J$7 zVfoE+t_eIv&x^n_@;P1eqMP0Od)%g8Huztu^s178g7<2E8-^5K$hPPaD_3`~}6h9#q%DhndCgL0&=L$$(Dfhnl)MsDP8w zXQj_GpgHF1|_ObWj;CPF+(HU(>^d(9bA*IyQLtfa1F@#V)n7(nqF%D-f zD)#HZx2SkZ6UL?sOl2&LJl?twqBPHow)3b#zd`4~-bI8FPme}*s;IEL8ldz76 zuZh-rsBTitmchH+n1=UmY}XHk7OohVx{7BYmxj#z(nFusp4C1JBZyn~GQ!?pwD!;G zymr~Ujdcvm@OC{OeZon<)Hs&^FACcY`Kzd*kJxe4! zZ3G@(T}nR;Hz+vr;mMDSw$wCN|4mor`~3(ny|*_Kzk(!Q|JsZMFO&%~tBi2cqc)(M z+w1BBGi?n*e_>cl7RMYnJf|<4FAS&t6%v+#C&4Gder;G0e5JH~PXPm-8O>;2xbLUC zM9ppGu3AaE_;ZLS*W=JK-|(3{T0dH2z?;=pFVKq@gsxPQ2>AH}>0Rr>nko@fCefVz zs30IIx_Cb1JOd-w|F;&YPN%klRLX%X6#i-VeSbhIt>q9Z>7N$dtsz$ur}U{B;lYb@ zK}34&+H3lgOw`xpFeaE5-4X{?^g#50r24WGHawr!R{{ZzWgB31L#e?2bmTa5(Re`s zmg>lzJE7|0NFFNRZ;MOlcCh44(DyfR*#fN*I{f!xkZF_PoXAZ$LL3DjITBo%^LyA& z#MD__8G&rBzM#SLCwkfVvc;|>;20I+ z6`7S6R`K8m`cXTv@Cjjvm8LW9T-cmqkUy@Tm_ynkde{K&+41}KrH%ST}hV9gEKaq{!`G1SX59_{NxiwmXd#g)B z=4mp`VMEeq@@VsDQ--+VyWv}{_tQxQP8EVCi6iMfVZ;S@yzM}@>&-27q_XZ<^t|DT z;}_A{3mR=>l-BJNED`o&R3H0<|C)+;0V#>v?^PWp$rb60i+8#Bu9rft8YJ?g9^UJS zFH)@UgNAIk8jkZDB2KZ#4=~F@q$QYI5SX1XDNvXq$>lq!AHgh;UCNJYM)5k~{$$6$ z5y-Y^H}Yhn^F{n$rMYKUZFg-qCs1; zNLMn@ka4Y8dzo`UHcWCd2Ge$+Rs9xlRe9jIy*1se?6(=r#wVJL#6KcbO0L3m6tboB zEip`pn=nSoED_npZ~BQnNb>0@ScOj>6Iu2tQRObtMIp(h-$aTj*3V`5P6WHl1&!=I z-L$niZ_T%uM6iyse3TCBY}8c|yz84`1yhDCy6i2-L}>_x>-G6SG1Gpemx&!44>1|! zIKq3~i2lG}w)qh4^kwvg_a!K9m8Me;hWu&EVap*2%>2F1Zn8$m+8BB}tL$n3HPKn2WY`+@(7fd64uu)K2N& z-+bOWMz3yZU^yOdDg0PQN3iZp8WQ zvbX)`F?E6%v27`Lg-VsGOrTs~;|DcAD?jTZ%CCo>2Z=lAqs3VYEr@JQB+w$z^1v8NGX8$e{?H!yF(F%NhOFQ?hId1DhCE%`S(@l_(4uJRi*?jB z0@{!e6A{E-yB);gn_NgAUk)|DHE+p|WMm5rw*Of8!lR5F?xdzeZk+~p;zMpx{)a~) zi97*{PU@F8vw+|I!t?31{`aTPyM}%}v+`<_m~ni7-YV%$lG>h(H`%-lgyn{^za4O#_!9 zC7-eL_jd`8d+`_D)^)QSiM;hLU`UtZ}r~+y0^YG z8ydCSEyt;5sAf3Br+>DYES58qWmINVM)QC0y?My0{M>y?K~Cmm*L9W&xsU9~W4@)k zr@N;_ob#@@F#w_$OKeLHPz)4XQ?+hsAD^dAL?~MD+MWOd-6FpMaQkINwRvMmqrD6v zZHS)e=lruCmNA=sEr{gxbRI4ZjFYDao2i_ zw${3FXAb?XBzJMM0_E=aq?n0V(3rNfKqNI`q|)M<>0_+6K7E(GMeR+x(O}`+@oWit z>=q#$GF&p;R*9co(w93;6jE;4NQ&lp9+=U|(hC1ni|g0l{4bgBf_}(edrd+ZAKgtt z1HrU(p3&h?R~LQadsTv?fN7m0*0)q!nYfa2VN{yG5%%*)BTRjdc|<)sf&RG~rfCd+ zHnz+?Q;|sVm-Lks(%jT+i!K=-8s3u1Ik_e)H&w6(*jEv>GspE+;#eCL@MV4Ep41~{5?2dKRCyRar$oWI>HAJI>F zpr})}&73WKlPIixZ?Lcd1@Z_;yxy=>G&gPkkqZC)6##FnX{@=rwOI2X&HT>M1&}Zx zvvv^StIPF9NfPgQ!?K4UfYl264}V_|joKzM{r^b12fsYuHVoj|##***yQPIE+ge(- zZLHNYmhG0gCu_C5Y}2y9Qnmi=G$JiGE0;v->7INR`#WNM~eQ{ zhgXsxh4?CV(X4@r{|>mV+iuuy5Tf_)g-pT+z&R)b3}$6xq{WzRhB+S(mh*6+q7t7&@(Qw}W&oY4=shEkG3)V$H#8 znDPFOU+$j_>Go=p*O6N<4h*t=VudA&aWzJe1Y7rmDU^kkTP5XsPK0f`n=jR0Ec_7W zq-_g?aVwGMV2@;KuTFe@V1|H{D^jk&6xjDD_{(eKU6=E@i@A&VAmc&fK`{q}LfC02 zSd47^Y<%my&6ORQb^qy?!Y61{a|`Q%D@g&=nr_PvjnL^7YUW5I%iUeo9;A|}*EIPO zp-bg{F}$og0l)`J6&2O1R!l`dZnBSMwAp4FU+g7IJ7g@7I%I|ui4KO}6lOcbzlnV$ zlNnZV#sRnWxAm*`MC-60d7OLPdE7Na7!BcFCcw@k%p-UpY1>!wT!e$By9)!hDYVhG z(HFXp{PxU*|BS#~SzcM1b;@sWDX>`*HpC4hC2}N$Jmdo?(niO3EZNgC$Hz^n(ul{< zc4wC|^1}oYVqKeZ3G~EKFeSnA{eMg=R*gjF?qo7Q!`t_4;@O^LE4*cV7t_NqU|9&-LUa>ACU=YZgr9fA7BplS^d9El#VNw;3HPb5s7(J|UzCwHZ3Hg>Xi6gy#K&CFJ3A>dqRm9=je} zSd77h`~$W*Sa2P!WfY`I(aF{G1hwFE(s|302(%(@%de}DSkx1k51|^1Isj^fuudH0 zw0Zf?Bwc_Cv{2r_-+2$+)UJELSGT3cY2wBkuJ0xcLkT;Bmku`h zeNH%>KZ)ffTp)LJu4v^MU#XEWJTX#iE^yhRRZNBD|DH)O?~?$=og8eAHa_6 zSw6k5y{|zprE&{e1Zlbj$W6B5uS@~E1pR58r>aX{Pn4g;t!gqt$y9K_u+gn#6s0pA zkYu~jt@#+>_DzFtP+419vQyt%~?(FW81K-%+%peJq{sQ2{hMTF^J|NSzX}i|#bF|!V z^rN$iKvAp77lQ@F&3yraE!7?dXKkpePbIg?o!AUUdJjt@yb`l(<*%A`7-YwqNSfPTUg2}%^hdRIcP(EN75gOV0#Xbv$*S)CN0H9hAtGntWM*cUKn$3_ zlwWfY$0;aF28%!BewqNXq_a?OfhmK}eFa0-d~j@mkjW)?{HRFSK)s-_T#aI1j7=en z+b(DB10p&{L9xo;QpD4!cd3Py%oxaEsK}crfXeRMH+zs!g{S5P6WxK{baNqVG7&w$ zsJ z|o7zVjaqW1SRs7vhl`-9{;}p>|@DW@+XX;K$M|Cmg^8IB>X|i zk#7<<#mV@bW|k;pxVuO$uq}eE0BTiT;RH{T3n8dgDu*OqM5qF20Qp1R_FxieNU|6G zmFli|hTwSiZa9ijIO}it^gD~yR4-ChSgB zhu?XlS5t!rJ~ALmHqu%5Mjz-b$CJTVSbkEZQ}7l!!iYOg%|y%M9)C{4ld0)HtBQml z(w66z`jhmF=|KeDL7l-aS?3$z-B%nKDZa@ECoKaQaT*2}&{lmq?mXAjupA{o=bw97 z!!kE&>;votABhXyl#a4AQC<%L1E7bLks9^YyrSO*SytB$L4?kEo}C%4j9h!$EESrwH?=Fx$0_R)4H0Z(Kx z7VNaRj!c?#h^_W{s(*gv35~o$J@Esq6Wh009-3a$Hb;D94F4!Z>IDh5NUp*i8%LC) zKgV@PmC8fn#BpEkAv4R3%#Bsu&@l$phy&LpzmCFz8;p*=o~mUV^Rg#dbq#3f92qYH z#krnY6Jt8bex{pN4uZ5Em@bV3Wz==|uU5I13b~NL{(#t5NFa=23LA{W9_Bkk)xeJQ zWglI^qWnt@ob;HO+;%Y|4Q)f9qFvIH%Ebblyf>j3x38ZHgtkv@#gfKJ6-EHftAY?( zr9~A&@V(kIy&>dPi`Oy{dVGJDQy-rR(I4CPR{sukkS3}O87nmaIfK=@E0o8P-Iv|h z3IF-SHQ7WWU5_RiJMky+6J$4^xtcGTYUWPa(v(Y-Y*I6cGZ&KUI@Q z(!W7t>Q0d0znj)hm|%iBX(?B~J=k3iE!lP5YFrhJ-(a>8(AXD5=MExZUc6kL-LQ7X z_y=4M{zRmT4UjMJ^Kgf1 zHL3;{_XVvZw^ob<#%D0r6e6`>B~pHLDaCE@y{7LdEkTQ?F0WWS7pG;eVNGTrQ~kDo ze=Ira4*jg+o1q}vNG!({CY$|V_m|S&k+-GEUmc8IJV@cr{;rmEx_|;NNyE0a?dain|OC+#i zOy>t5D1Bl8sw=@dJuZcbP@H^S2Qn@eCsr(tG`2s4|E?9gK4<18*^lTVUudC;t$gA{ z`SN?joj4DeQYE)KOpQIia?(43&b7|`KnCy9M>$tWG-ps@2qsrB1$xSKYQemN6r}WK z=_>7K&nvou5}-x?u(zG7R;@)Ymm_oiYDipptLak#?3kUzxCgZv?YtOI z)>;AKTZMW`*?J;9e@Ucvpf#=Xj%K)()}Dalm;nuP?x!=jMx~4vG>sPWR!s3d&n9C25U54e+=E{jC8tD7}~-e0R!Gu=mE&BKqm+=Qk_KQpO+o4 zk@59WT#5<*1Ge@om-hU!rvO3hyXe60S3&%&%dKcmk&;xZ1X*h?1jc*N)%)IOU-+}b z%_s>ML*-$y=^A=@L8`UCMvj*ZAo$^3&~}Le+g6U;YXmXNf0Zs#bR&Q1z!bC`Jk}L( z_n=C<18{<1k6cnaI)G#JEErAJiquZU^b6gW#wa5tH57ttHK*;9eJYe#?^}6-S4HHWd z!xbdV&o0O|(;znwA9J))|4AzCRcL^ka|3Wo)XC7vIEW~}0I-+VSBzAT5R#o6thXEg zg1X)QL`SI3L+6Ydx{BP1=Z`iL4_qJW6&Gr0qNM0HW4#wz9m}K}REvAT`_|CDeC`GE z@PE7U-m~1Zcp~>+74FGR!W#nz9;Q^lnLH(|E<>|4FG%F&(IYYMhxhrqM85**6YcWa zMEKEi$plpoB-yne3tS|mDFot`qm=~clRBn`7zxni_w6$cq`+*#omcLi9GeRl_GpHU zVpDPONuBU7cvD3)K(BWn07||jMTs#RZcjN^)bEum>&UPAu65P%^~Y6nRyQn*LOa_@ z9~WQu>2urF(fYFA-l?DmDGmzjM?*Fuq%|hrhI2)_m+JRKTe3N}cN<~Ugu~MH-+r{9 z!T3aU{$7QgJ9$2v^0sP{zCG)W)N! zorY=_SW)g=A^9)SqoQZk&fynt$jZ`J`{r=Z6aa4Rp{`q1+o1?=Mvy}i0L$Dr>%wVZ zFtJt0#cS7js9ogjvEzum+5hXy@?#<|kAvN+cB!*VN@m3}%7gNrX!aY|w$^w}h7oSk z%J8ZA|MS*rXdnb0QlCG+h9&Wk!n%aC_AZOHs&`~PRth%|!R0_Nzx*B^f79D7n(#L4 zMbg}tW>o5nHTWSM|_0( ziu;Nil(F76?^g3fwLLMOoq2^tm7qwHDTGu$Q6tcOc!bf;?5<~rk*vs+sm%jN;R6UW z?zHQ)GlE&u1YoZRtiAc4JDJW)0NTqLv1cth)$BTBw?T7imBAL!0fB*oHd zwd0|ZjU>`hOM*+uZHD6LSViID6{sum4%A*r3P^>yz%~2vUnhU2cvvq zKWSld6u%x<&FoF9CK^KXlbDb2kxtD~a62m`StED>@^%NURr0lPenri=ntMLOA?WS% zTk7j z`4{6h6uLr?FRXJO(a=$k!E!$u4rf`7CBcmb3a3&Ku){6g2F0-b)fx{|J!8sK%_uL<{NcGc;ihKi}FI z{9V!GJ>@;6i`q{Z&5Pp@2xMWn32T;-AA27rBk2fw2~XT1Z!zp1}N_y8Xh(vOja4?qk`g<^%>4c;@DY|m-# zCHRV(uvR>_Sp;*@dB3_)#l*19T{_b?sV>mQNZcC^0xY!}#k0M?Akg}V?o$;a& zA8N&L3eqII51#DEk7ujweoiAYW)iR8SNN>%&%k^1at*VyIz*vS z7|jS0dz~#EXeEeL?k_o>N4@ig)vr@7dW`a?8#a!&nh`=%v!jMWZ4^X_iJ)G(U) zqww7Uhm0vl?cnN?ah-VeC%GpY!29UxQCD{9TO;Lx|M?i8at?a-!&34KS~Begu6M4# z66ardTgF6wGOLkvXPTY3?owu(m?f%dxNPy2ZiS^cD??oPI^2#zsc2bD`e#4+8c7UC zIN__bK_QHqNG&kqVHSqrNN4Scuv-(JV=H{E*-M>@9S$M)x?dIC`utBJ$nIhxx6UlO z!bxjuVEv=?ac3uB%k2fv=*<^S^V46}y%0xWT}t=I)od#fO@x{A9uAL^**04ZP<^`T zr5PepQ2o7^aId{a|DAlGiozskG0U z&nC%(G1^%KLZdeaib~ZV-8BzdM14c+lV}YU_ros6P|eQ#v9yYTtqn~d^U~<9QZ4!t zyai+=Z-1sKux{v#d1!BsCC})AcL-_7^nF0Y<=7)G5NE$5W*`oG0kWd48vw#OBXNw^lz+ssZe2 z`DuBz*;0iC<9+61<|Az3iPFDp9>{vX#jazhp^Wd`w6;tzhj52*4cNIpg=&Rr+thUY zD$W$@dg&vn#gfOe$FgHJhTV-fFucgH;N!Wm?`p=+OKjgkxRnt&=XfR)Q^7 zZB}hs!8(>d@VlYLtyu^{P=*sbi9JbhJ=(NciUrC|grrQ9)KbdTsq5GU0#!djJc#;e zBnR`M#$9zb^xA~SWRY79;YU5`+$IZKD34HEnAR*X-Ug@J?q;+u*_L8{gpLau5JROK zB;#NKpvkkawsveg(FR!@y^(wkwq7eo>vejTZ(oHahv;+ zzza3X6-e4FAdYJMy+yRg7lp%`-KIgJ=cAdEV%1bKY(e%u$_ww4C_F?`sH$wQH|Y14 zueMiC*Ry;GJI7(0-h^Um1n!FTgREP6N3h=osV}be2R9VtPbZp;4ts-qh&L0_;4(QO zEQl9BCdhF%BqaMFymOblMt(BesP)${Y;2NKbn=<#vTet0^aw6p)bcg$fzo_A$>}qY zG1x?Ft2{?CWcz)drUrGpaojrd?+2(7XaM#o7^s>lRJynp2Qne88fmqws^&CpN7OLF zl&(50A%VxZt^AUpt^}c1)JW zJw`BavhKg~(&keRSDG7+Olo*vn})4AV@NWr>&2i+Xt}p;p;yj!8n$al~gEeH=xc(_b$TC}LCcS!e9pq+pBS?}&j?7m=3h7Ww3b z5C&3xuno*UPW~>w%H;52K0mF`qLgb=t`z4tkuaM;5#gM=y4jw1I(IYF6YmqRSND?4 zamHiESD1@>&vXs=O4};iD!;dZ`hciZZHQYgpNtowG=uSKOEavV{I2N_#movmA60$n zyOIyrYxZjP9FR6n-X%l-xh(+h5& zP%Xe3`FBJyguV^`oF9}ywT^3u+0OObywx&NK|LT<)D>Eo2sV&KhMl3!Hrx~0uiH0@ z<0UumEFq+aQ;0IY0OE|YRC=xgpGUdOPeCYueoD%3RUhJ4gTZo?X|&SJSkewzTh!NO zi25qK7(I5T2con|Uw-j5-U5vfWi>yNW>vS3q=79u%S;aNb&7VB)&98{3@`2k(d?d? zmc>YZq|4~e70V0(fA3N_(~aOz%*h<~ubx@`x=5jpLfs^IH1}xM=;6}%W#u;5xFlUz zafn$2^tU6-ToT5GZ;^0rm=E>Tp(`ylIVsJpZR zIp>2aDUXJ*nphi@y!gFyg4X?dpORjK3t7K+DG0!v`YhkI&;}i|K7B@XXKYU~kmQV- z{P|dHEpWVx0$fTv%2*3cMQgYH#&lhk>qtW{#QlGo7JVhf( z!RS~HM^hf;vhJfQi=zs4B`_?N|TceY{*qL)Q^*6G?Q% zoqFrLScUiXqsGuD&~By&6eN@>o=w51grZXUVbls@p6E+iaiSL02#k{`(zlgx1~EN) z`Ko)^ox1h8u|j2>B5ehThe}_~Y8VUEo(XgP0XJX>wKT1H3-QqUoMoEWJ!E7jI`Vf{nQbt0Ydqa1pR!9;Rq~ABoaK_` z(hpV6GAUgMRwyh-;!byn+htszbvqew9AUfyn4li@EEk>?L9(D6k(PQ59vT3AiWL1A zz_v?l=_sqntc6r^`)}}uf^bNsx8$=e(87>*llC} zG+a8)8G5>e5{A-+GlSA7U6MnH*sBC;BDC6@fX8wKV}8^~k-Sm*nv!jLujtDe6_PD> zlFw|(+dxF+gB=CxpKrn1T6zFlg-J@zcR%-k=cC7ngsQD5yNS*cE1`(6--C_$xL;-T80e`TrEs7?>&_{q_D_ygV(F>bn~DTH^{410vGC zHG^`>_dTIUMCuccC0iTC<5SFbv`0Fz%~=;e-%j5tW4&iBWK{>cK8eE$jn=5ptVUq1 z68%3XoMomRbS5Fp$Gg3p=pxx;Xv5l+YJ+$+NJattVE78&yPw++9VX3ES0K-P(Jyd{ z8~C$+0hhq*Nt8jut!R@0Gq>_CQIOd~_mt~=@R>b8!K*-f6Ueo<|bo2A(!OC%mbdxnJvZho9gnX`}pA}H>^ zvhB0s0$c)IMAzSYEexuP%;$UijaXh)XRs%P{Z0>D4iaBKJ>r#pCO_9)XAUU4UA>gN zyx+bUHY2}_Tjq5>ozEewFS5r=~sa+5!sW=T8;+&nv`HBA^#UxYiUD&P&lIzs}5 zH{`b%O(Nh?fn-Y9{?I24POYsTARi4bc0O)?yr%ap@GVG8S@tx0S#SsST;^q}$Dgg7 zaCThNCTR=`2js;XSp(MEgovb20aLv^euZ&rZP9O>itU5yAKMo0RBFys_}3nMFZWF4 z8?8e%5y%$WYlGpxVO3_+@nFb}v>b1`YpqP7f=68?3{m)efli7 zY?bwbBN~4TGGkiZzv%2AQ`74X@%xwoqo3g{q*rQ3%y=ncn`Pfsgz2>72Ot6sr1{rv zU8ujYspPPCS>BIjrGo0$rA9Km6@v|^S!pd-lIsr!WI@@~Op7XK+Q$qEUh zdRYjbQ8>1ha+dHE_O0@QsL2}+pN4Pw{frXbicVXDD~nVKz$ir4pGs8qQ~JQaIE}+n zKS*-}9j!UoR^Z|GPh2x~*5c;#gxX-{h2rYAA{K-VvyDp3<-OO%w|iM%DKEaLi!{JT zL^bnHwDFR$k}>P`?9=R1Kd9hdW48SeG4VVyW68Pu$_t(T#|I(Q*5TG+uWYgkNzI7L zvZc{#Xd4iR{@cpm!z(Ok71T|QQvW<+`RN7~ze%iQ+U4fMJ!h!eAXI0VA$I3jCYV+r z%yXD*i$jUiz@ZARm_3f$8Yjj)HYpKF_EdtPR9zHrV_Di_Czxv;0Yl z9$&|$p&-~GMq`UcT__cq)vTaMt+av z?W+jtpb&<5Q0e^Y1k5ft1yP{Z+G~zrJC%5gT+)5ii)9}8hjh+O0(ZJ&=!Ln1dX4AF za;3jpRx}#TA^R%uaI{U@(=gpItyVnWPfK=|dN;a3MU^thH^ABU)+)J%j?LA;d6(q9 z!%)4+fCWZ|uf0#*n|&Lr$lr->K<8iW5$Kpelyqj&$_i5S>aNQ^u`3ZuE?>_7EyvpZ zMW2hs=B!71^O@z%8w^yV$YJ=!QV(F6$!)&Hu!8Y6k;nD3#Gp!?(&i_wJh}u#-&hUj z-+Un|HZ|&|fKQ%&xO|Evt&6uRQ``#f=@#9hVr^lvE-C;>j?>qVOjKA@`0c}&`i9{N z8fuWOLKS<{D*PGd8RnYXV;zCPrImYh_9ks7dG06s+Bg-X&N;r8Ykbe7;m`H3($S9Vz&zResm-rL;XhXlq=0|Uw zxpxTMywpjWCWCbfB8K7LTtMqUBKC72Gji? z6A8EB*gxa;_*RKHv?6>FgKjnQ>#E0M=(iTNq42@c_@gQ9^`S*&<}5Kk_)6p)WpW60 zBw3FH9vB#1L^wushi{LUE+!0IoUpSpM9!(DJ$}*0{bfp9$SkLqL=ZY6%y?HRgu(G- zaXZ@Bn|Y{sb1z0SYR-?+haN%7G9El_Q8X&wE@tOs=hT?}BN!HxgX)o|s-IzNyz9ih zf#t-em&QCs;dtkI=gJGGY@}>7&ua`fp7-#9A$;LNLNC+?g^J<>t_w0P7NKd69kM^eIfnBE#gzCU$C?Js^>eBl=5F#v8DwJbj8b8!_{_L zzZfM89o|u#)HEtuXHN5gmOEO!oLpK!2NFfdDeF=t*x5?1!DdJCRf50Jl&G?01-`*p z;bj}Rx?|$7G8t-jV2pIJK6M@Y)bhSJ6dQBb5@@6LoSFbx>3Iax>}2gD)%A=!ao-tN zQcmUJ=jGoe-dOnQmnl5U1v}g5t3l zl;BA473QoIw~As-#12*Csld4MGnGG<@fqaxg( zlwo&{2ohc;aae=D)d4oJNh-ZHg^xIxJ3XO%l^=7iZ-PcxHT=t_zp%0JvhY$6l-_He ztZjZp@FRW{xQ1wH2UvytJG*WF?8fxORtx_x$A7ZH~`6jhsMtOKnK zIy1^I-LN5*8p7+Z2QSBS2pgb159ik7$;&^rch&fjoh5rD6?_~&7K79qAd6vm0XhmFZZgF6b54tyaX1NW#$Oq6xZkV=wjD{KtP+~d~ zGbCe8gy-(#?weH>?>x9Eo{y1S{BEKALox7ggc7NMAJThX0b|9d*2Rj&WxKCD^Ks{# zRMQe~9>|&{=WY|2GDv4^noUu^8qfuv2>zxGaF!;w`p%fQ6kFC72QT&?n_g>(wVh!i z?806J$MoK%p0Td+vqhvy#;%Sqh|>UP_GUAA)`hRS`S@&AD$p@ShhEVlWQKS(F?Q;Q z%R0&Qr=*82A6PKXV(va+jiC6n!%@*#)6D#%b0{;RbNH*jE^=DXZ8{K1*hJ+F8@XfJ zsvXVodo`|{Fd<(7INg>zl*w4+L)PFGP%XAE_0HRU`@I@4AgAGWM6w@H-Bd0xwar9E zha`&ugQFs)BBhRlfs2U}ND&zsogWCP0uGEuq8W?E!WpI!OQH~Wp5T`~{wknR#eWvT zZl#gy-+Z@Xb#`~`bK7O*S4O&`7^dM8&ksb@?%_{+SyiWCDajNoqe}|;3Ndc1A?^ye zWLt-#Y%EfF5^1p4AE7Vt!FRvze$7MY?|qt# z;ej>CLv|(Kt{FD^{suwxvaydYL)s`+l~TJkNG$rb8`(Xe?dh*ULhm;gnKmMOR9HbI zcbpF3SZ@=(KR2*eW`VM!pTmPPGIRoGm{Yg(LpdzsnF6;ys@8AJ-M5pTE#Os`3KEu= zs7HQq9D=h4MGRsqq-OBw;?@NR0pp9eB#5;Xk1ME=+*)!PPSWP@OfgWr{kow*?G5nDcndN4g&1gWzW%CuG94vl@Y1SiWfS zG@mfpkbpX{3IRE+uXSjU>eTKTbz)girk#Eo^B%@vm`>3TBv2(y$WobmMjg-V8Ppju zKp2!zDl?OkcjcO+17Q=N@q0e;(tPCm)NNv`s7pZ91&E?TN^>9^!xz8>WuP}dcNhG% zIP*XtQYJUT)9*H@R$iN$DODl$2JaF11r`yVBAh+egsL-#xZpWgk@)$JXE!=M@a=E+ zla^6`Rq*TSMea-YTR>~{XM`ARD1Ae{I2(1!UIon)Aa@8Yz5KaWSVn|$Y8@n6N;-qS zj(QH~3EjiEmvS{i{Wfv5b#w6;=m8eoB$j(!^+NKY?Z94*qWal`IxNq1OiZ57r=+&L z^&CJ1eI)Ar@*TD8Lq-1~FDP4`)~(_uuneJ&(2RG0C5Vi72vuG(?uL7Ao{x~l&dX$U zfVKCbCim^}p;;nomD)R17QW(KLF8=k(Ch{ic=!o@e{QX=IXWW2Fv15gCzv4rN!XXU zhJvAc#OBvtB2xnyLIM%89*I)h9xw}S@&bPk-Koe4ArDP%*qWiWoQn>FiRhXkPQDCc ziy_LF!m4_n6FCw#r@x5ljFdMAow{m?Qmz^!&8QvHU$IR?;?qysp2EU$fKXvLfonsK zKhc`Sm}zjukh}=STPu-iB|I_;-ooZ~d#Oo1nXaSP_n5I(LK9e%(DI0%^skv>f%HGw2nv&e;|;mrNGJFh0UJ=0T_(fZSeR z&X9`L8IrgR>b@Tx`%nfi*mHJrcS|d_G}l;V%_}MWJ2o6&RIL9muCkW4eY)13SX41} z#*dE>?q5pNI&$H?urF!0o5F)vVB3)oCA0-At7;(5n9i6SN|uejenL7>&m8hc>_rDq zQlKJL2O9&?H>HrPjt(u&r1YVrVpwJ4vVE`I!9z0JKD6Vj@T79*oN^pk24W9dq%i%E zb(>>&9uWVOzFS-CX8hnF5_^Lb8YvKxmtfdk+XJK)mS-$l{z^xEP~H_yf1@HYa`7F% z;C9^K|5*?b-#29yFXD2Ie{cJ01Vs3vmlS7ZINKm)(Rt)AM>#vz9}bt(R`iwqQ(o~u zbmud0Y+HAQ+}0SXNYo-9wo{aS%)rh8-D;bxrrlUTt;TQ z7t3!M{q^J>qJZ4cLRwqzx$DY91Bo^Nt@Ex&yX94g|0cxhntGDoK91 z_x?Rk*o77+`t{jqD`6u`aH4f9OOWj3zYE{@k7<%kw=Dp(mpN8OdlU=Df)w;udc=5k=A)>Fe4eVZ7J3XuG zQI#xpGzxoSa1CGBT-fwpej^XEX#1F z$MFs`d^X{8+6AYpy@b-IwnEDLs%>V*{z&Afby3=71sz_fCZxj6h%`;szl)a33Z?D9=rq;$8ul^5e8E8`3BYgElES6ffH81bC# z{kLy_JuTK*Y^c^8wHI7YuS$JW@}j$o5b_Ck$;FYILeU`*CyiGx?+Ja8_E1KO;FXA? zt{X|6cUEyF8X|Ad{wFtTx;qalyM3#)B?r01RdC(OMkA#0Trjy(LM!3H@6&!9 z?taX_oP2RWxsT;c>su8n^>3Y+?%76m>2puVY(XusIn$VD9ip%h+ZtdAV=@kyO$`{6 zY8z3HNVcD7y4Hi}2rjQ&)AxL_3Qx~));NAvkRy7DKP5TEnt+yReW|up43ie7#=s=F z+qy|t$x4LFsz#&X7tY0`!SsfpcvmiFOyz5Xx)vB-7jI#Gj_129bk)a(Y+bapCF-h zmbJ>yD)~HmpL${RbNw{99a&fGtL|6bQ|}@CbWV;vMHA@*N=I==aZo_u@#uB)&-0u< zAJa0>y~##I*my5cH>Yf$e7~&-oAFmaP7-3-u&3GA)*B+>Jkm>ZB49eG#B)R_RKX%A z&hr3GJaBJG^CFS?0eO!CHIRhjMBRNvaBe1hgeTw-R)1nA%VNu!h~7~Tg5A`n?YVP_ z@hPT3th3y3C)t2jhUzrQcHW0NG~FAMqL(;SyO-<3Zi;{JhoyNrqM0tXYV|HIg&FF4 zhtA@m%{NjS>%4wx6_B1x9-ij#5W4%qPNS6 z`@7=_;k$i;lCJ{ojOOog@3+fd<52YpRMdg1PG>D1%ey9o7Ud1|FdabrQw^1;hc|#` zE3JFPXr~71EiGV76z-KEAg&v(gRv999O7>F?XEMepGj#>*tZwYSG*qWh4d)shO{&K zGkOfU&!NRly*Dg7G!y*$$~vC-alwL2SV2$bvEuEmWSBGVh(;;uUM0WPIDbjrVPHA* zgtwl+#vvX%{=8AJ)@;S$tT@ySvKVKElhe26zZxF1tV1pTYWcxyG2M8UWF(61L8+c{ zs8XfNf{F2m{_A-DCL&mWbb++tIN9LqP%3aax`e%m9ldW1aEU`Jj;bO#BPhG)MO#Wb zn_!6p`W9`IxJ=rFPbVj*f&7hy3wsx;6J!0*9tHtF;>%`$RO69i&$FHXE}evqf_R7D zM3chz$H)g)L3ib;bS!kC($$g`8)>mj;40mN&gLA8Bo9$qlmJ%2Zs!$5?S`~7z z6mJn+t}1~-zrZ*P238h5^~kqIVi|$QP$RB2!qQj`ao+Xbt%IL=*b!5O|7Ep|N zF`OvKznmcH$j0}P2*x3wcPbNMHTPYf zp-N4uR-&~}2s5Y~>#}*zVR8-4tKdp{FE0G=pc1K|ABqyHAouYMTcnQ@>#6wT?)CUV z=Ek3T$x$@s5bVip&r`5V;$O}ZDyczf+k-(YqG7Yr~ ziIG`)trC4y@vuAzP!RZq)_$~?0&kpWeYQY_aZQWvDml4 zd){^3rOvA-*4)UY+d-4GU&Q7f*&6~JL?M;JNB#Qgk-obT)&wt^g8Rm{fsC! z2p*^kZHq3bU3O(uSk7UEe3H$u2k6>h++EwkkTpWc>ePjMLNYP`aOSkv+Q7>fsN}7G zdk!+D3(@KJmfvBEf0Zc`?Msqg;icV;KS^N(t|P)|dy=qEuAGs6jK0{rb_-W@_ z0PV^c`Z)UA&EHJWr=E&fHfW@l77wTxfvF=Y zqXkFj-@~X8J(&mN*Q>#OEMW#n4sb>fBfLL!w2Y9nW>Z6XX9FHPoOYY$^nS--D$6p? z)&FRs!ml(h0Ai(e>0t5!%#%M z5JO%bQKGyuh=oRaLz#>yNOe?6FU$vwa#UF^{Oej0d82qb3z<`Y5nNfHo>#0}cpMw@^t$!Ea zTp9a~-*C^1!bhBm_}*=Ffm&)EO*RD1eIA8h;CqY?S#P=n^UOgUbdZmXFDW^RLfzTP zA{!?A1ojgJ{c_Inj-ixP)ahSeTKiVLSmG_1%wn=QKP))^{eqoTJK7REDs}=AoN;G+ ze=meFZ8B>z!;^R|e3pB-A`ftV-R}rW{7Y3L_bcfB^!`*EM_yFzF`a|>=V57iLAeMb zzLvTEw>l*PAU4$EM<-2SDepv%C~FYDX?WU`-LntsFt118!>X@C@yK0q&Nn~s=m%{t z%xeeTj?sx7{Z7asN@Wc!vYAGxncz zNgpkUnQ#7T(6-jjw_n{2o%kA$c;x@;5jfq=%lardpzah{dB3&B9v=1t82zr< zn1?tMe0M(QZQI#oDz_d-WrAs3o^Df2@F(u8E9I1@68JMO_kC{FZ=l5>Kr~Rp*Q_n< zq)YY=Hno_GIuW{~P@(J(x)`5eRuwD6S**uECPcaw$E106$fZ?^XvH#>NmnU_8pch` zuQ83gP^?$=hvYN*42vQ5D9(YbVgj<0 z(6oF%dXi;2?FCg)5*|l4D7~kf(8d zFU}xWXkf^rJ&VEXXU2tlsxuG-lN&W72tGLF!d{m1!vBCbDB9ceLElWk%%`2$29F-)v#~WZ$;~Z2y-yD&oVu^8H&zIxB0Aeo`U%598EW*hF+E->VJg3cTVFG5a(gPt`kauTY+m zc;TU)2sWPm5#hU^=`BGMft8t6aZ~TT@QGh@c_tYm&J`5#5CSLk1Au;FxzFZHdkvZ+ zdiWoKv5dqSyY>V83GClcX68K!>m~&YRMSk`|5!Q;zbL-{Z7)lM zbV+whcXy|x(nx)1q(i!u?q*fGC8fJlI+q4%aOr%8@9){`ADGwd%yKyAzOVPaVC4gd zPZA^HNtTF?Iw#zFq}>V~)(^of?>*#H!f4AC-xByodKcTpv7LS~8YD2By`u&W?2uT` zk5>(}zmCVZxO#m=HE8~5G>h-vryMy-)ggZJvjCuWAZ^50kq%gRthzH+QWX)>yZNwY z;bE@3tDCB?8xb0ci770Iq6bJd{B^JB@XAjcTUHL8LVbO%{vGaiH^WbmyPO8?{6ja4 ztn8gnsAIIzn4pLLn;PMW9MNzt9;@5O={f@tj33y`Wh;nS{r7i}?ODG7)?ZJZV ze`J+>>w48yTT~!4gOfBT!JVD!>zzd0b=-BzqIBe*XZ#|@FqAOLaLRB3sw1=c?uzee z)BXrF>GJHcad2k^Ueop*7w>+f_bBuzY*kXXe)8-;E~hH=R6a?;g1Dbex2uRDci)H*W(eDDj#OYDZLrVz`Z2->0lRfpF!zbu2H z(uN1_dRH#`~OC z3N0*O_Mat1YNt)16`i_F+prTd#h!V?^gyLff#hV8eAGwe3UiFJVIO%b(n(AjkS;%1 z@>E*2?tyx2=mC4fCM%Ys6P$bCz)w9r2k%K)g-o#lH;1H}H_Q`@6JIam`SKjjsX2)Z zJe50kVITdQKqwW66D|YqYR?`@K%Zt2fr-a+cn6CTw%Z>VZU6pty?*GBdP~u*#=S!= zO0V)SQ0bIpIzc`v5*i9=JvwcHzrA|&4Paw>&|7L65l6Ji^_c%?^MqM=owjV~OItE- zS9kb-!%oT?IiCl>LKq1HD*6SSkEas9^1m{+5qfJ{=@9Ei6ev9k4scEI7v-ft$W!+q zG?QJ1-%I-whGm*te*izGKc%FiHrN|I-8;O#9&UGYWcD1YG&8d<%gfItMT_V2NrZCezRi7jfft2bd(b^BqpQS zT?1K$+4%**JuWL5#5VNh3(6K#?oFyh0=zq%8G1#j&4gTol%GgBbHjdF2vhlte70oj z_PJh9E!eIOK=Q~Fjz9hr9KlC%nJ~Gl0~>)t369==je@tdF6CkU>=jU zIv;m@qYhMlPI;uHva%hSPO;jEy&CX6W87|<_#-5Y%r#6QQ_Jo$#-jgLSUxD*Y4iC+ zwc*>onA1~B$R7+GmzQ<1&WEPt-^&Yby+*6N=2wyTGHl6LBQ8w8D>iCFxDz@B0-d{W zu>G0ur=iz1{(aXtD-@x2k!9q-zYMZ^3VI5yGJD3EURItU=jx^fKa~l`K+Kw~xjhQb zD^)RVVq)LRcU#djaJCREnV{R&?svTCSJcEIy;xEGk{*^r1Eka53)*b(<)OS~y7;Oh zGwK*fSIzfE%}6UQvj4=Sx2T&|g!gF>nA%jt1!NL8<-Djt>Q-Uq0c3CcsOkv*N+RnT zWb6egR>K!?1;=`QPAn@kI#>27Ttv36C$5}VF)6L>O5rZlLFXJ-<(VU$^=w$Phi6f- z%524vzm7M%&JasMn3HaRFlH1Lm6qBaRr_Mw;@aY(b{%bAo#%zeG;u>&xa8hWmJW7h zpN-$_ElzqM=%~zTc_51EYRrA3Zlh|Wst5*cRu)KAM^WOTeJEO9&cq{EG)`fylbaN4yW*XGYn||_&(7vf1jrk!H@mp2pL&CFW8P;g zFsiOZ^5kqns`T{B%cbV@8gw1|egG|`Ge3aPmmC1HS1Z6X{(1T96q=3w`{n@lTcLos zeE8>2fxkN6wk^EU^)m1ZKU!MS+aD?C%dWBBjGIldk6}w~b@R7@ptSZ?qBH)Yl@I;Q zp3DWs2T@x#k^mVWHl(2 z>OxgtB*4y4lTKyCxPYQcdg!m=Z6A+v#eqOUASGETois}1nIT^8+^%{~HYVpnZ8o+U z$>5uWn*@O#Fo^G+Rx4Dw=sM)C_woCY^2UP3%7L;$fs~PT>CyNutqP zPTllZ56Htoz`ZM6%$Rc{XBMrAJ{eNo=tiD3Sgj-67aJ;!o@g$X$-z8zbThMMqS-U zgLHw;MJHj;HK1<8t?xTtsa;#-ILyI^adcVj$M7xC%jpaMV4t2!;9gh@0ornc>D^Dn$OICL@YNAN=V2v$JbV05<-m z@94xAS5j9R?Uvse#y=doLLnOMy<4M4t>)$3H2 zeW-^}lLf?vilkj+0N}k>+E1XK=Qp>0k7AxL;s^mEow@6nkKzH8of~P( z33$5EG}hIhBOp^0N${k?aE;u>93@ABYP_Q9uXFW&PC;sQwp(3^R~ z_zXZJWcpZiNR?-1jF;6l(CB9`z2eJ~|4!Zl0WUue&(XMVU7qEq-!WE??{{`zCDlmA zO8V2fIKzj%8#h-E_g*rCksS8y^f%1f#P+!SM0i%ngDR#Ogq>w=qvlUX9F83ZB_PiA!E=NCNAT{WMX zw}~kJGSfPpII%j;LWABI%r4b(!YRS2!dLPI`Wm!a`JZVpcbKB}Ar2w&x{yi)-Ws%=wrR>`keRc*pY zi6@CC`Gmauy!;L%?s#j8@d}VFRB~vwY4@OA_6!Uq)0?zlYNKcilY)rno#N}Qi#(PV5rI3 z=L?~yA#Nv~y*vEkA)d5A!LV6aa$h3u0Oyw99N+3d#$r2}-36`Iz`<%H?T+F8`8S9O z%z!T04I-_c#^ESvDwMLl4uXF7`U?-Kp3?toG(~juZ5#pJjGv$@Mvm~mcFf=5hQHP5 z>hIAn2w{;+)O^~I4VUiC9+0|N;NhKiota<$iGO25$O%D{{;D`$oT?!A<`C}xwfeKb z3FVF0IphFVg}z)L@<<_*wz}yuu(jbM4ooB*NNAO^KFQ~5?~iCx@JoR*ahdIDbo59{5`w$Vn`8| z^O7dntdzvi?o|~p5wnXIvI_p1o3wuTQIejel%AhrBFVd?k;X@t{(Y1gcK^T{$XR*U)2{KWRqlM60z8U9$4My(*)nvJGM@rG7|O@!n_rOkXG#T;Dpp_y)XqlWOPt zjmmSq+d?W2xx=rstkjjJ2A#7uRE2@cFDbUzvLT8!$i$z{Q$YSjVt?QJrciuk^2|!C zNzv2=KB;{!KV-j%n6q*rqcmS>8)^NWuN*b~T79(jc}9$I(#=7fX1I0`!!00-Fp z>GzFV+bHpv9!f}UgWLa=0$}YElVSU?f8%`XR?o)xAEB$%}h*o zYi6Dypcyjwm&+IVZ~E2fy=V5@7-_WoVr*t8jZ%~ll@{`0=)IXZi5hw*6sh{qce}BVD`Mt3?s6~5iSP3DcB-A}iLAf~OCOB)B7hWoVx_HdT%r}Fg zh!<#B_j(>?QJH+$r_M9T+Y7@bvRhjO#Lp4@b-i=g>T1p1D%{ zP;+Q8>lfd)o?>o_FtZ2x^uZ}Qq9fWezNHkjqV3~dBo&}tslI*7$uq91O_Aw4jn)P= zaZZE#`L?iVMcOf3wGwuUhng!u_J|vRdd8=6kYj~j@==kICe9m-PX!uNlm$<{{d25O zGh9;}p16khau;-hhP<%pqWy0bpK0`xt5B6$8||R}`OTrLM{~=nr~F{ZO%8yO)**o* z4glQJx^-ao6I;&P&!76Daa?v9X`9HKF|Ip1Uap?1dpn$O{9Dfq7wdc`_r$W3B?pQ9 z<@5hw2eLlvJ+h%VV*rGER|9Y;t&aQCRK7>Yu5Q}XE8{bsFBV4>RL5H@e&WR zK67?(L)AtD0PYcaMe^p4zdPkr$903V$P~$?bh{=;{hQu+$(#9h59g%4D)k3Pthf6f z3BTj#`_{O^a48HLlM_K@Mqk|CQ15SAVj^d_ujVWGX_^h$I0 zgvD9khg6xD^-qN?4<}_7)_A0*ckQ|5=I~BRugh!UMzIIh=L1*5IG22=wBmgmWjQ!R z|D`JQmQpO=Xloajw<%s!GzF2Vg$j4xS+e+mHMf8hdc!L7w)f^qb@T3NLEph zR6pcX0Z4r>cTD7o0>4B1R((@C%00$ChBtDSx>QDM-*Dr?5ANLEhv|36#(hXbLMykI z)u|!2F_AG5GX`J_i!00t`HT1m{Rbmedw}m#z37m0>N-m&Mp$`|?xqeWWd@cY7IT!T z3|gIt19A&}iPx+M)Zju(bEcbg3*&-i+1n5Pw(@D-1o^1&9J7SjE<)G>t^y_ntn1nj z)0EoYPaulRWE9&chP+@|wk#Q=gnFa*KyC?$p<2d4bR9B5vFq3oqv{*f6x>8;7SSBC zU@HR})#e$`b+Y>S((4ENH;2j|^s(VMszhNzHAAOI+Slup%V+*|Z5(d!S~a?o8RG=l z8v@`jBgJJr893Hqcaq{wzTp22*KCQs$;O@>SJ=tnXSG@@v7!qSxr*?WX=mOSDRwZg zR|KIHg?8wfmLJJ1@*ERG!BV~n6h_vQ>1W+-P9_2zLw63(7#hD*zG<;53!y$+JX=8P z8l^Z9FIVmzpUMzVZK%i67uX~{BgG=W`hIxIMOL|Z(jwDT%`A$|f`f#Vi?WSc3y;8RC;S= zW+iE4&gg{*pj|4rYX!o!aH)wi?n}r@7m?+q$7`d=m;4b?y54%~^)n|%i1gd*o#m)GAjL52ki3k6G0!iMf(MxXsKJM=tK{vHG zwJ&A(zjYd7`|_e@`Sm9RJm|FqbY%*DcytwH>C~ZQ#{H(eaILU^3G}f1Pt76`e|m0@ z-i9`fxEfSxTgd>|Oc=yO8G#>u6tx9tpb%htQb^hGup7!ng~m{?-t0 z|4O(0S%W?-fjL)$#`;A<%2E=5wm@I0ItkO#DC@JWJgFdTBGYT)O>OK7EhLs-IPOie zFT(qYcQjl%18_oRRb}Oegu?b+-toZ!|!!=|&NLqhMde`fsqG2)1uFK5gm)$j_)P|P68;2%K)S8QOa( zLiA&9x_IXN>tA_!t5gFt%0dqz!c-KWZ-Tu>M0RtNN+(Q^ybIf>O>EC8E&&iECMRJq zs<&_7yg`zNz?1)Xu5eHLl!z@#0lbwJ?dW!WDt@27nq)+>oKaQOIuZN=u zMfwPxr}CoUm*k^PtRUUT2tnmLbr$7RmzwSpvTi?w{*+wp z`P@*N4pi_QjcFka`My111I7mcMem@xW{ zM)PzK$60Pbt#dImB$Yv*i=IUrZ3nN?4&^`(U7P-6mW^MOBPAL^QFmj3I2B4^S9PNJ z4)OH_%8GV6I9>KrpLn0;XNHpRb|u39p|_Qy$W-ztX*$Yd{@^xa$cj!uzJmBBxUVGU zqC=USQ!){YDwyrLPqsgLu3H;2_hZU}y)zZ*XAzjaRSA@^+v}tV%A}vtQcXJ8$C$4$ z{;pr0`SN1pW|g7PH?brM>cdBHrwBuw=YT0ooJ;P`nuD`kEhA5SSJ)h-;EVfcQTS4g zB5`7W(&<387ru7-f=ji7>>t?jt7q7q!T}x`n0Ku(FQT#V4=@07&J#7if5*4CC_~<{DUXZvOEj0_Oi_Wgsf>#95P#2W`*A>5G_P#N8`A{S>!c7^})O=JA;j z(m=mTyjS#3xhzrEG+_HV+#Y{k2tXgz5Caf)TL!=qB|#j>{aldxL%kMtqm~Y|l_53( z>lxz(R&cl`#CvkEA3lGy4kVh!h6w1ez7VCS)r8U0VZHO}@&pC~DS=5(|B(OJpIHP5 z{`ZqF^?Vh@3MgnY|NDJ5N*;E46}Y1iK-ay<{iGH+LwPxKZ~Ih#Qep~sD0G$Mi<#NN zpRmK*`>(8x1q+Jc93lYM)(tgt=0sr83=UDe0`Qn(^H5piW+sn~e}(=tRci~+esk7K#uNx#k5UoT!HUKjlSC_uNHy=vRJ`b(ucXmQpb^=l!-kYF2a{%a| zRH0U(0^2O5Dca0fQoiGtSqI3}WE7YSnb>|3*8%V3<{Oydi@qIvVuz>LqSjSILvfD5 z$2Xxo3fEo8!U%+e76WjfQ{GVCoYqO|GAgOI=RsIXl@Ix%R}Oi?4sa1Yf?GfuXtoB_ zxkE(9Pxpuy);=FI6x%rVV~F93;t!HDKBd~<{8@@3(jZQBbsfsHNAK!W9aBy7FX~Xh zefSqu|C6;OuIy*a9KZG9lG~@?!l}+UeEh59n`yEOZsEa>7du61o8xt?y8TVbmFRq? z{a-Em6yx6%%>(F5g6$v%af)L%!FPRMq^m?FxP&I>FwYJADs^f5@b=J9{KDHW@vu92 z18fD!XXP9Iu%bT)1a^9%m`9~cxAig5#2on!?~?k^|5L_>KVv^*=U5wv{IPeIoYCjL zA!o8fPLcgrzPX`s$#@@1?JeRh za!WRCQ#7gS3@)A1E-$_g+j!V`_>0){_riCmx$uyB`rHdUx-47oj;Un(P;fnTxv24v z)>eW3pMlBou29huOe(}>wQDwwrn4JJUorw-Au~-lc|7QsDOH}*Q39BACSWfptQZg2 z+)hCF1mrd>6ayL+=z{j>rn?-!g2tPN5`v=5#0B!R52JQ_okpWxNG@CNjn^nu1!mM1 z5T8n)bp%ol?5ue+@`{Rma5F=E@G{(!ofv3}mSYS4{0H8!%`1wJ^<&S; z*c0gc;hhQR20z8GN^Ndz#iHSJWNIOvM}5Y{C%5GKpjPP>ICwT)mANEKslDe3t~}%5 zlZ?5l4X@Ab-ZD>A$U;%xYZDDILw@wo3}*+pTd-_E{3FFj)C-C2z=6O>i*(A?#}6J% zIR=7&UB&WC%EkNW3C(u7D?&a(>7}Dl6Vp>YCcgIBOD$u`mx91)R(cL#M=$7x7>?a% zTshG-;gLpmY=#oScg7Gyz5p^vUzGuc013z}ZV0;$QI_@ee-OAWV-XDRNH5jkRb)2` zZYvmTbNr$0dxsMKA)PK#9I9>WFp!IKke3}?)936g`*nSczOr4?hc;7ckScRnw<+!~ zEg!7XI?rXdEtc%+|IFh`p9mG#!9c!loces(+i{lt<9Zn*H!n4kgXK?y5MEKDrM7>l zn#glfsc|1Nc@g9}rQ?G(KDdlchT+mHr!f73S0-oiDA55e#nzHqH8o0ZSQ`>e)Xbog zhM3NC9Hqm-8huvUjCUTr?&K~G9Q%Xy8Hw48M@n7kipHA{W>L$*0^`fdpYXIR3}>?D z<*tKON=_#6((vPiwgb+JT!agQMzxJay(H7%J=cDYDpW3{`}DS%L#eoQx-o2(6(`;W z?Sfc%TMl^}(+W$BNlnIvs zZ#AMdJZ>7z#LS4{U$#p^gZN!5IVVHJ&Ja_$kW;A}hzP<_h)1_DiUD$E==@eDu@ORd z^DCYii}EPGNMfOR8(!BU54p)0PQa<7My`TuR*^;5%7eW$URDB~*~hl3I|=uv8@QU) zU13U%3w({l%N!+v0|s(;o3)Q#5koNm?onkWU+tJysvKHtPpB;n2I^ykr0?{KvDv(> z{~gSM8zi4T!9yvdkUHT0HnvoDAoXZ(G8c?9QO@_q}W`Gy1pT6G6Jak+!De=Cv86)2VC^aYTEsg7lM=iYDVn&`IU zU=^{XZEE9j`Arb*q-=Mg$S1Jo23#*o(_p@{{LVs8E>RW=922|XCQ9c>qwQb}1=nLR zqhuvQhNgp%c4Nh2MN-IX?Z{ZLq%CiyE})4N!nCAKSE z_gv>Uy|g{qEMEU@RA>@IL-r#({#=8cW9MIXRXU&0#N%uORTp$y&wQ9zMGntJ6Cv;f zuj${+`73c|+=fcr!vB@y@C`O8UpQ=lXdEWr)Ag+k0?4$<10eNP#TXN};%=FX#zbO2 zlK`+BNqZsGjZ|=#-zwmphTDBNh{E?)$GsFsh24eG{ZV6NIW64547h1KHS>yRf6pY& z4>e{#Zw+1QZ{13B$wcJNe)T0e;i7_Q6IY)yK6-D z$YF8xXNH2TIRq0SHHM39$4I{#U)iX9H9~inpUvGIhMF!^A1#CrbpuE#I;TLH+TUxr zQJ&!ez&9`Knxy-YTOPd2E!^C>NFLOnh{Q`(*Aae?ie|#-_%=~}EPJb~=dZ}U_F_f7JLPE5lSy7dTk+XBb1DkamStrM+dd28b@GR z#}LcVj{ePK(=yY=Es;dzBe}F|H&}?Qkz1r`!w%7tVl{t>s@ z1Yw}0#r;rW{oGOTo!IEfy*oy)ItsR{&OArp5^S3j3}Tl=d-h4gsaxF(C0dTyutj*A z8Ntf}m3iCc10KtAG7Avs%r@fGRnv89#FdbooZ`9U8kH0!Rb|s2#SaP4?X+`s4Bf-d zs2gAM&Gzoj(xqA3RYwqHMN~BdSIYop#GuN2raNjW&ZMR4hV%FA z>c&^pvJikgcbqiDev!AhJBX1iohJ4-}VU^LWTkOH3H^4!kw)gyj;PrO`K>~EgNAZn<#$} z?z%qig>wFa1~xmECHe80vop(d{0!Gr*Jm`$!5Q{E*X3TsqXe?*X!2Qx2V0iXHvVZI z;MUCsN_|8tZkuGp&|R@`#lcPx&?X<81-lhCYu$iehyk<|O>;T~+u1GIM~%|%$P4na zeVyzOha|EBc{}m92)yXQylWai*moJ6e!x$=P%7hQc&1x$e$;mI_}TJ)O%WHnfsow& z2VSnCVm~eebYk?x2^hqfG$W9&J6UG)tu4;J-T+Hi0H5i*k?Z7s#>am8CiZIgpiD;{ zhU;8MhwSw6(LJlAt1!ghI^?v?4nH&pE@nk;HT9!KaQ>c(0Kwf5Sc(QD_Abo&XNR;x7 z*d_!eb7ldXVJM2X14ljO@A~{~iNR5q$#H2N#6A4x*)Eh}XOU+|O1K*bY}5E1z>hG! zEE+$GxoBl$JY(3fG{`R1Kn`K)FQF~}(hoj;98Iq>5jB49c|Y3eC7}p>$%h2YIxM@| ztg&%vwZhm6BCX@@_oOD`b7<>bejsazbvX0nY=n{o-eIPwhtdK<8tK1R-5pI-A;&!Uo4FNm7p zVM_Si4)<#GbeKOxoRA{5A|F%K_<@eeTfL5oBue#OltD})}-j^ecYXqz%Ix^xZvXovgAr0>+9BC9Xrn_&*-P;>!)11 zx%MI_*GE}aPy6Vompw-(ED$|mf)3oR8qmlV%}uvQiQ^}W`AiRMV_X-s{cu>154Hp@ zfb=w7K$^s8K4K#EE7)q$MY7sSxirXvEg>@NCC;+~Ari}!C-D*W1GcdT5x9GvQ!$M>Y42(Juho#Av%OYWuT zh^T7m0A%0hTBnn5)x2@HUo&Wm7%Bx|KA&#mDU}Rd}2Tg4WkjZ3uHe zrnHix@c?*zVE9L%D18g;+xcSlY4mA?#Y=5&_4NPx`adi2F*%nKrfC>NX^QSQ_Vk2` z2*-(VCN7D!r1^MH)-QAHBjO|C7yJ)npWMW_*&5h;-WoWQ@;_mhuI@u9^svgkaL!`t zaIjLob@>hY4Xz;DwUL~i;1vPY32_O^MgPveju#3PZJ)5zFs#PuqsZg?(->9SFXP-< z4Cph;9<^`C5#QMS_QCm2S=)mm$wdMLxUFOpC!Ev}YLpd=B*g_EuAbms;&QSih2LY$1Vjz@HYJ;n^if zM5(!`eXpvmEUtUmkg$_9URBVLK%z4ZjOyyg>^H4!>5(;Nui{HkgF&TUdDkVM|M(Lf z>BosLt4cb1-0977^H1yj0!B>Z>vrv{u6L_Hgj)BKAg2%8ekuLc2 zes~~sa)*o`{WE{*E+M5)wxxD*8J9e!4FWRP1&LLDa?4pAgiFod;j zB6fq(n>E`}ODT&2GKAN-MJOVBA282E+EC~9ObmU-WzGk)1KXN;!yKKR{M`KXnKIsU z{)8~gK1V&`2>k~u-ZRru{n~+@c-(GFY)6{F9C<^HQHX^z^Us`aEEI2S+4MHtR8d)N zqx z>5#@Fv1JH|f`xxBfPzdm5KSZ__^;~nj~u2}F8SM0Z7okjQhJ#qwc}7NhE@>+PhRX_ zOjXSLM_ElwpoEue_fAhZ1$%{ig|Q*i*b zf%LDsm$q(@fq30#yG~B`xpc*!k8igMVTH%=6LlVaTBHKC!9rtPGu>_WP%G+^n^`}* z7$)X1Yjh@!Ul_M!mIi;((1*TY9)<~bFF=6C4!24K(|eNP&h>Pp=H;-RO`;KBy==*b z_l`PhtrK2~&&6d@=c?zbbd=opHkTalLG)*AKF)jmicjyZ>Si^*Lky*wLYk-p1OZ0) z3FYC*fk)(I zT14gF=K6;&`=987;t@ipz*tW0Wwv%%S@K$cEF)3qO&0iW$+Xu_(`7q$GEO{~oBn6s z0K%$&lqcT9*pyIDJ&XoDhUI^dW~F#Pe;T8MKQgbu5&nM z>$aT3V7sO@m&Z(acWN7h%mUU~uGAF~3~IvKndd;k&?P=v9X`s(#pHZ*b`PM@EN zj9>iWDu8lSmaRz8HgyGw9!B|Bq2JIq#5dNf*`GOdDhz(v^_OX06_#=6`lBj4Gqr!e zMEW+>^gLLse>5xHK;iwhc$Os02UeLnl-g(_Or+dXk}uQ7M`FNom^$>~SQm0%{#@2U z=X)vD<^!$QF-hpNVot(FmXu>D8-W0EY#mA5Tla$Agb;^!O_It~vy(aq-#b^4Mqq{7 zL+|Ojt0Np@HXAMAN~-4;4!_Wu1(=yOm0E@5S~yFmrN+c6h&KC%-t~Ox7S>!Zb7r<* zpL~z-QJj+b(&EQ(F(o(=_Pj+s(HoOqxjA$WZx&e;-CHnC+=O z3=Zp4>>VKgnbTV?NSa%lTXzRUVZ~s@tb>b^4=i0@Gi0+I8*9gF6;2?IExEQoih~|S zK>r-b6W$Z~&aheRB836-7B1rM5f;0U)TxkVY!OPPhq^7pa4tLPn{RJS`r&J4pdx1d zaHK1X1C4YIi`jqGE*S{FCoCU0{knc7VTQffSY1SL`SQP+pK9jo`VSq;Hw4FJ9p(2` zhc(W39lH-{y_=qqE96edj4FBWd}`@-+VgJ$pbwgYH7;hGl1bKk>*pBjisq$TCd=!1F%tpxuOT1t zU0@+ssR%kSjz8K3@O6f$&y@=EF%P>(2TLsEA59|W76XPRwhC?>=T;t1v^med`bTDT zBclXfa}KWJz8qXPDp=?k7Pkaw4e0+HZ(cGMO9(xoK3V})c4EQ1;b9H+0Pxaw?Vwe> ziu!l=pmKXlogCxOp8ZP+zT8)qhe}bN-vB~uq!y_h5{!sm6APn>m-ueh=T63g48!a6 z-2Eax{l#1OFM+4)?C(jtKopIg8owka5nr7PSi$Ej=Y})-8A?#_g?zLTmTlp*@&!eh zMGu!bGfH}xN)J1CAI%%=;ky$Qmu=dymVek#3TRbz0@ro845Y@yyuC+*>I3dO)K8EO zP16#YgjzN$!x5$^if9U@14Kj-bWg$nkZ%~pcZn21M|R0EPYDpLz-L-j<}FD%PFDeT z;%bUK+QU9h(W0*`xKsXZ*%ur1BudA~NgvTSP2mUdD6miM?SZhwQm?x1G48rWa9OZj zR{-6wHH@|%R_iRQLvc8rA4xvwnG<}77YU+qpnD1BRZa~w5Tpg|+|nsUKE@6q>kC40g`_oq6P)2)H&?7|}UZDC)Hu_UED;+UFCXLA^kVemS%bgZpz% z*{hg9Sb)e!brm^FsYN6s-xT9SyhdeZKGKtNw?RDV{XO-=q;y-oXcA(&J;H~s4a&FC z{q0I*KWDkDUTat7iiG&=Ce3jjq!H$k9)FnutpprY)4AjZzraatElZea=G71n3}XuhE6=Cab{Y&i{CS^&j$QO5S}?VYePi1`_wVFS@c81 zD==yhFW1^Mw~Q(rA6Nm3@HP3~%JQmRt)BHns z)T-c&@P=U%I8>2pu2r0J|8Su-F~2LLc%2ZUVw!5~D1-=&F1MPZUp6#;q_KP>N-=56Cq;Kz9*6kilys1h~_>BaGiyh`_}9i5g} z>t_;D(^J!RQSLLui?D(ghU|CdG{9*^rNH7Nk!(-vwZEXm{gn*1R%x1!6*yA-#ehzt zZk_^Fa-9WE#|F?&5DphC$b($?!oni+vMLzLhog!YTyXCKw{ARdwL+G5NpL2V`?#9O zlBc*=jN3e+zvDjcw&keGY5&nt@(NgUk%znU!y(?Ega&HT(cqU`02|L8;{$992y z&N%ltnYOm^YZIHMSHw58MQ-hfQ=)%i96jj-=Gz;JSDLg-^J~-im^U=8itn|lZy5lP zLPn%^A+=TmX<>l0g1Q9MJ^2du8`KB{nLgNb;Fy8#7}8l3AiV=a2VaRooJgd(8Rl9i z)z)Bhz#^!p?opP*SYdRdDc|S6(pVon^ zwO>4;k&D$5dI}Lqur&HzPPSWOR@xrxpilsMZRC0>wBaIAnUEUe3@B<_Qa2$r*6OaA z7n0H^sISgk`&T1+{zAuau*g1i7I?{dEWL+I)qgZ{+mRbo4b zzcHg{owNL&piTTct6Y~{B(=KU3Po3PKr$bGbvV}!Q!67?x{bi3rrHqcqHEd}RB9S7 zB!|!Sc?_PgcB&0-&krVchTf2F_-^J<`GCqrETeVIxIjsgdeoCbT$;}88#YG?c*9NH zMq)bg5q);_&}u@4>4`w9y&S45mVmJBn)oK+8(BSva`2CQ@YB}-x&5Gf?Wf^XY=5D9 zS4;kaqT-@rBdpS0?a^X)P-pu3sA(KXwHyMmk(%sz(meO+-VgVZd0f72xX?p!X&&OP z+FOR-0Ba(aN#?>;e_xpL!%mzwayUCvYQ>xnY0)!QQLCB%o*^+txs#ZJM3~zlm6-oh z&Q2tmQ!wsHr%O5~-#{(Zzd(5ue>F&_+VfQYiq*1O4IXj22|SuUK^2P;VzG5@mWLf7 znWIa6_aCI1{a!K3(>rWWj^+0MZfF)S2IC|=AL0JL&2}ac0Ea1tP#*m!U7=4tOejA& z2Wo>=<30FFfr8dM)-;0AklV-$tZho^Hf;dBFooWqn|}%z)0jCCi-P*^KPA6%TwhXzJsD#&z(Xy_2!I@d+8t&FMxcB}(p?82MeUI! zSiiS?a}LyC1W5F#4c@ZF5K1p^)%V+e`(E?WyspRE#Rb~!gS_AUFFSp`?a_K@DH$kH zW99tb>7!?44@UCA_(!tS-MouA_1i6t8x*6o61&aGE_R7+kmIJa#V z#tE6z3eyT?>~XL7N~hY~cyZp&nRh4o7Osr6WOQ!V8kCVgreP<#wb_ISckTqwXAoP2 z31~5_8EE_ksbesCOCo1wbQc&3aYfNz*q`QA7*TPxGJg1r3KY(5Gy~w})HDjdBuH4MDOOxr8$q&-f z(gtvpYMtY5(+g>S_3bh&5qGAjG^Yfr{$0~G>NypDnO|YyLg?k!0VYs0(A{L;%liKi zXV|R7Es8uax78#nL!XmN;1aX&9dIeBub8e?PX7K+Kee+g2aWzd^{@VqGG5VW>Bop$ zjLn}(={4XBPPRypC9`4xC;BY22bw*hqpM`>dy83x>nD?U55~s!a7kZ$Ob-M{#V7bka;9) zU^^0OYi^K1=qZt#E_$J=$9+XQu#M>Vq)CkWC% zBLsY&R>4`eD3A-DnzRP%idgy;>|uQZQX+dr@gJ)#PUhR)Vv5^Sivuq%(Vcs8n)+p| zbMR60!=t!ObE&n}v$0?%KMkdyOZD>qkEMGKtNVZd0G@5PY}@X{Q%j3$*~VJ7v5e&w zmd!1DVcE8A>-X;S`(BU#yUtZt=e*AQe%;Tf@PU#)aF?yr1WODT>+Umzb3vJh&ZdAz zvimt_arpOQTPE0HP@zI4R%E;-Ym&Z}r{2M-%4wGqdU7@b&2Dn4&L$-P}`FI zlYN7@jzKTcsQ?T(BLrnhTQM*|ifC~>G~Xh_DIJvaIQADa1ThgC^ z3aYBqnkz$I?Rl46eD31(Io8vlt!h;khlK{58d64L9kv+1%op+8CwHprYrIu&WuKn0 zOP#70lUvm>vv%l!S@kEv&^(pUJe1y6L2O*-8n2B8(el56K36>B5q_e$y0L)(#C#SN z8id!Pu-#AEu6p&m_osAVpnQyv4vc2w7`=a>U?GUe^#CJT7RC7MUz{mM)7a6asg^9R zh4o8TSQ>2QuxQ=bF_Tl}Z`BHQCM-Pq%GFPb>ew^E`6=1Z+!avW+9}1cGeC&$dDR5~ zvZG~fHu7Wf|KdTbuljGOqbvO#Jst&@VzGfH{)WV|2X&&?DII8(oW5nE)u>e z^p4yXj~6+E!aQ;83&iHyzW5~++j*Qvd0 zU)$gfhgWfhg`YA=H+%tHnH>GWfrB>*>}5u`dx`OAy5HE>QXPg}bNrziWS}s9LikiQvu((mIN%ZmxP zP4MP$x~#Khsb$Fqb|d#ZE=J<``#f&Q5xMKv@Cnew#9PDB9j`)D>u>g2Uw31n)phCi zvn#OOa4oPFo^nssfng-(Sl;sX8<$^N$FM=pXff9zN`%n|M5`jRzP`DBfMmV|0LmC{ z71oH>9!$$xIdz)9F=72qWkWqg4OaB%PO`Ar4I2Z*6FP$ zM$_6w%)Lp!@(#N(;*s08Ce;b0n|n1MP)9O#wU$yU)VR!H%`A?Gl&(-I~(kW_7d{~ z90Nq2Rc;9a?K7&Z$whFOFP~hfHGcCr?ljFImYGOVI3>wp2ydhRv7T$0HQ z4CZ4#FSXYI)+D>UtwnjV6JV_Mpme;&aI$6gN%aEHTIFpm1SleEvMlN*%ek54Tvu&A zMSjWoU1DcV6tO{cVFdWJK5}mE&PD!W_}Ens{hL%9TH}Mdl}ZCu(!NffLt&!jY+&`L zd9WDkU0Sx(VfiT349I02!}x+-;)9bp>^V^f1DX2|Ei1MosT;}5%#`hyNzK#{)9?8* zD-?TWk;uEagTMG=Ah_WeOdaYVmXQKa@M9DE|bk}lYSpD z!%P9&IBPoo7bXaIAy3_VyCK7=xH~zFi^j!VThLs>lwiQG{cqiyX?f82yu+DBgUY=3i=ht@4Hw*_`~_Fp;t9Y zATKB*2i0BiJ$jjF&nc3fB(tQM=;;(mqd$jq*bok1yPs9eadO__A=x4EXiTmL$d=fW z1QI_y<=btt_JpziIrfTzrib|!;S(`h{5X}K@weB)| zkc!9_a+P(MK60Z+Tm~!}vT~%PYS*I8sIcFqJ<&_07JbaG$teUs^XmBjBG%B04;2^5 z-*9Jz3O6b^P(evMT~OUD^B{e{ioi3*YyJTlT61UdsTI~zn#n~$w5V1sV8k@| zAt8d@)fdAYZ!0)nQ3`^v4g6u$TtI3F;0a1wG_y`&fX96;K9>yzEdQzay2C`(jhoFqhstPS)^#5Rm&~ z%TGSU<8)HZ&9^*Q&v&BuWcpg9ypR1DOz$#`KbR{&`cIN<9R3;-@^XY=2*Ibf@7GY5 zGdGE%?D*Wi%{5PW{!J65M~9G`uISP5CX3;ZRL%X%XR`YMGSjw<{>WZPWM={8qF~tY zCqGs+{<0sN9v5rcvW@-5YUmo;8k#?7Hq3q)CNvviRK_2t=Dj};Z$tPtiuUX3=m7|I zT7POkd%|EwPKF&KCm=>agOl7o9axEPp>VR>UL0t^U`9`dAEHnd1CZrKzayU%1`r2w zbfp@iz*NBj0^gzmsQ0KZp}swo5Qia$5-z#0$xn&b&CV#ybN8+;$t~z_(sOTTkmZ}; zLP^m`8-~aM;HRDNBtZw=1jBDkMiPZ0lDrcYE$2FezW(q}0G zM>Eks_F>)`zHXeEyDdKEyZ{XE^26t4_x2OAc=sHb?rVI(xl%*#FNWLBRI4pX%L3U& zsK6O$5Qy z7Vn(46K&if*G<|Z^FotCFD4&LPxP4!%7>x@H~3s3$JbNC$1^0$mlX|SM+UU&Mx}%+ zjIXhy*j=BpEBXVz6lj)cP!H27T1+iCD?#OrdK<)!Q(YrK=8Zi4Z*BaU9)QsO+i0np z1*V1^ua|tE*cnYwa(iSTBc3mkc-SVWq3cVyLnI)Gi|=RC#c;Hv?R8|Vv zNZ>xn9yX=DiZws03_8RTmyK}4qE8`c>felr?aGN1&gNocQMCF8k>XU+gnI4p$cIPq z^gw^#^K9e`8{SUf!y%}EqR)Gp6#t36CKp2^)rakiXmi{gMyBg4~8B$^F@n6Ib!+plfNPF$x zR2U^D`_ysM0=Bb{o`C^n!lxUI)PIGw0#T_&9nio$`_R{jHG?f4ZB0M8tAW@`9X4D` zhoy;3mr?=pCI{l`7y^h5{Mi!!%{rUqevJhxN{K^l7#WKHD@W>Up%|Y(kbzPX6E3^- z3rrzElqQjEPc}r6aE63nGFmrWB%TVMmTYw%ZCG29%irL_jd%*fl$jHjLwOkReUmg@ zD_MhyGsK0$VEOZ;7|^V|A}hFgz%fCa>=2Y*wL68xaq^1g9!RI)Fz&Z6cCF>=+UY%H zSq$5iyRI^h&?*bS9B`g)5m%m@y7^Q6G_vAw>Whpx4^4Fq60_R>oH#iCnvld05~Idl0RP>%=#Zjv&fC$((Ak zW&*>D_ty3p^Sr)D1eQTix=0iaw@@?n%Lb_U+PR>JY1BUoL>RR)-xx5 zqV_cXvR-jF>lJ;n_fO)oawyFLD>3t z)!3oh`IQQ}JZayI2%d4_V3eyZk_BV_EEO$J;a?h z$e<61p{yCMp6h&?0L1rRZ^J;(qVjxI^Ni#&$kd9v8CD%p=bDL<3a|na-ptVlORP01 z&&F;op6Wnrxo6{U2pIXY64msdahLeniygCu*p+& zf9cxpk@x)P-Osx|@o|QIoMp5NH2{|*{hP{b7h6}=&fFzy$oDy|*7nUA70J2r86ok$ zenK*f=`ipefX$SCBy!zn*JpPIen!7R%g$DK#X8{7u9j_tZJ_>NL&94I>g=`{i8_x) zw89cN7TEJaOZ~`#F$ezeRN6v=<{b^exkpZFV0Ys48W3!nFqOHh{6yftVB}i-jYaZ? zMdg4|???St8)3P==ZDNO8s1TLasOh*NyA^knNPNV{1+UDR7CtgC+G}sS?dIXP@I{7xKk{D^$zrn zig$8D2zTG^+zzV+%h7->$>RRQ8c$}#smI{paY!b6Nr6On8$pMk+{)>6a$ijNA^PNS zvlw0+p8FiATh*{1QZp|1AxburiDJMeem~>7*ZO^yWmS!jspDgE&sLS)ny0d0#&^nj zT4UdRPi^o!24p5d$UMpdB&(_BF^~NRBIEI?*d(N+)ulkDUjQFqf&xKZNg|)nu3a7l zeOAQU+p6v6d0XKQo_!$R(}R77Ii>$mMHN&6g%MVngHM>Cz?mQf>1zV4M%-F)CP;(J zf>KlklXMRmLA+(;V~dUwc=KSwt}-a*1I%@iJrQ6~|8v)>>W6dXpd{3*Xth}!wUZ*V zWL}0d_XDy~DlrJ{l4larwBF3oj0*WO|AhZ1h}TmwSkM!Kf7qxF2NDGzDvaOMUb_C$ z&Of=HyWr&RfjS|T6@*lk+Qx<&4>%V0cj|3^>?HT0DgstnT6tx*zttxmz?)Y=dQ)eRil8DnQVoaS9?Q{JWh+?<*z@=qNnT7eJyQnD zjwC4IPAQBjBOa|`qHScb%f&?4ILyo5p1`r*%-O3S*@ow}tU9%%BO|E|ZerbOP9nj0 z5We*Am7gI`cGQWCWJQDRKpN-FKdC^l`#uv75O+$mfOp2 zJ$$wC?ycZ4ZSCM_rJmpgA|@wX3)RN`}1EvFrDeO&r1aJ7S)_TKkU)adh3 z5VA#a-RHruyuLM9Q9H>2?L@`~{q467!Q>yLg5(BwG{H5EbzJD$ zu?8*TT509~`MuUJ!9F$O{8BfPa$2|Ng}nsX@nsfLCxC|eQ^od!Ml*{-JEj%3gS=$q z9mZLD!|xj4GnhZN407OlKo?l~52;@5KH4vW3N z+!*ouq!4w3wwx;!*ABezbwr{J{%Mu4z%0D29sPp->2rP%Ez$6Yy1q;*EcPj>)mSV4 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�FH;USX1K=Poo&YJW|q=o{i`IJx*;i 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℘MO$T`XE5UG()e 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�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 z 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 >SgbtTgemk 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�)XerW&c*bJSvB=)8hJ@4n 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-hdpi/headphone.png b/app/src/main/res/drawable-hdpi/headphone.png new file mode 100644 index 0000000000000000000000000000000000000000..d1f6b1066d78fdadacf16918c162456223372673 GIT binary patch literal 1515 zcmX|BX*3&H6i!uDl8RbdDLSa7sG%84%uEPEtc_h`-%63ht_ZE&Or}|sQCfytT5GA& zMXNeWIZ9DWtP`=9wsu2e$)w3S^W(jH?mhRtd(ZcM_mb=|<{}_z5C8xWv9vIC;94~I zs0s^lZ`1&}j%$uZIhdOO>iT4txsKp<<15AhKm!eY;Cq7W1H&y`qW}O%`}cFKE3EPw zHz*x#hK+U%3yhBSjSK+T`38qZYhuitT1F+U*3)^0RT?8S(+L<1))an_u$;k zB|9JI?W{XKz1E{Ou8`eu0FX(;kJ<{04L4b5gtFx+%dK`npyjs%D!1`1>f?eHo=u+D z|H+t)X>-*h0o7a|D!Eoo-GVah zwbJY#91ABl*m;XzbcVHdXs?_LlYsbv%q#ExHnb)Cjpk&C`Ta{sw5JBqP@Hvo#K@cJ zTIEz4;r0iw#~|gzZ1{yczq5o?6}p-|Rzc5-uVT~d<&C>4*@uJrC=?1_`R1NJM||u7 zB~V=wH2SeT-K2yV7Pi*LV0gJ0%$#?A?9zz!hg5naoCe|?9UVtUB%l#T%1?}C3QIo) ziMo!V*A&zV#UHxo$ zk#s>~mfQ%FPr!himltGrcUP{YnsUCsw|CyTOmT)TZ#!37jbK7pK>-2EwbBZ_Z%{Zq z9xs!DvAP)-7w4_3fA;z2%_usRM$6Gs<|lvyS0C5~KG{30Ne3vuJ_+ z93F3;D<%M5m8vd5y)&_yyQDRL`@p`Chq3&O#+Dexnu*_{fo@>)pUtDQ4P7nYs0#+~kx|^u`=AY7r&n&g!|s zEe3-Tyj=jxeHB+s}r9A0*mO{g%_= zvxsPe#Cs!Eiun)eMKIR3(SiQ;Fm^5pJ+gf`x6mF*RUgj}CvKLtl`( z7b0)@rR!Uhfq{*a9b_t%jU#7Kl`<0}dC+AwU$Xpc;g>w=2{cdUnEClNj3w}^P%iGC-Lcn(KlNe~pJilBwH#k0cU z=XR2LS{K2%ySoo{U)z*&I-Uvqxk5lRcr zdIe_=_q$azwgbpBNioY2sXxA2PTJy6j>|iP4rTUhD8p0)XG;hUR$J12W(Ed>fBuT7 oPEzMC6|MLywfdYJE1n#I#8^>>GY%{UcNYUJ%`m2QCO)bE0lR+F^Z)<= literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-hdpi/help.png b/app/src/main/res/drawable-hdpi/help.png new file mode 100644 index 0000000000000000000000000000000000000000..69926ff31b33e0c626b11110b5a67e6341769d15 GIT binary patch literal 2122 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 + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable-hdpi/icon_poi_tab.xml b/app/src/main/res/drawable-hdpi/icon_poi_tab.xml new file mode 100644 index 0000000..8cbb2d3 --- /dev/null +++ b/app/src/main/res/drawable-hdpi/icon_poi_tab.xml @@ -0,0 +1,8 @@ + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable-hdpi/icon_rules_tab.xml b/app/src/main/res/drawable-hdpi/icon_rules_tab.xml new file mode 100644 index 0000000..3beb26d --- /dev/null +++ b/app/src/main/res/drawable-hdpi/icon_rules_tab.xml @@ -0,0 +1,8 @@ + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable-hdpi/map.png b/app/src/main/res/drawable-hdpi/map.png new file mode 100644 index 0000000000000000000000000000000000000000..1e7e97ed17aa91e34f807033815a1f913c8010e9 GIT binary patch literal 6389 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 DkL&)J literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-hdpi/message.png b/app/src/main/res/drawable-hdpi/message.png new file mode 100644 index 0000000000000000000000000000000000000000..3b515719e86db4b85f9859824e3f94571eaeb258 GIT binary patch literal 2258 zcmXw5dpy%^AN~Huno&>v&|u*Mr0Am`IuBP#~hM~ zN4;Z2q}h7XSb$8*9uNK|Uo2 zxVV_$%w$vR1xbi;#>xVy?mILq03rcs2Q&cGrb>SI6%}9!nzbtf0IGy{L&(pH^H5OS z&%~Z*x{#P;B4A0TGKd5ymJ&uJQ)$F!&q-Lpfb{MFI+Phmr33clP(MdvPaj0J?6Dp{X zi3})(geQ_O!l$k!#|UWccWIrep>#YE2xKy8jK2^FfgK8-OrrVHnQ$sS06`!!eMw}5 zE((b}f%q+|{eMwyzl+*rfl&%ENc-2oGs3#LfcN|^uO*dskxmK-WCE6!I#67wADM)Q zVyMBs0*e?TfrR(ny$N(zS0Ib069qVoh^GbzQz?vJ(zIVYgkLL&NFtqz(1q(DI>%eL z1R9Xv-u;>3zH}l$6RmK&NNAw+nT1d+F!^}6#f4FZkcn6?E*VeP?OXn-Y(Le`D7))z{x33?4c==Ec z2&s44KLRNpw^!1=dv7A3q>o1yjGj<3sn;n6VX;FhfsNG zX-mY&$nA3w2ZyaaMHiLYSr}TsFX=YxQ2c^FM zYvbm~;iP`#PS*)j-R7Lc_AMa0XTILpzAb7a3A8cK|DnR5%W~(>aq4R3n4<^{jo^l- zpGQL?w#iwm30{9_|LMm6+iXplv8f@@a^2}2DR z%BzpvEu9*g=5UV1_jdE3Q#$f172#v`a}d=@nV>Fxy@%>uuB#4bg1?%SmmODoJPlr3 zZTy*jt8M|#pxeu)XNFE~#CLR`ZF)PAQ8+ZD92i*U-jp*E%f5oD$^VwE=p1c{LR-+@ zwe3jDI=?8m)Rv-jNvKE<`K2VKPb2dEo6c%O?Uu#-5nzL2I(G8bUG*1U`Dq7-A zCN*y4fZ}If@Z+)jfI^mJxxrce3o0=;W+TKXWW2M%pw?q9M406No(r5V>XUta(augq zYOa~PKo46IK?I4P36Xk0m^XP}qz)4^x6Svjnw=pZa1BCcCxf8#Nt6#q6sq1cwC-DR zxq$fHE#6^erJ3TXEVn!J^sr&k`F=7)0XF=mVn5&D?W@%5N)qJLr<_$et{FVd$~r@L zsR&Wqa{EhcP<|dmyAF})}BDMnB$U_ z%oFu^$P+%p8ZYV@co(mbYvtv3-Cr9qPeE9=(8uRmRmQFvs!aXsI_dREq8@nvKR$2Y zdsJ0~eFwhPMG@;@3wg1ZeKZH93}UrV#`mv$f!v68!O;q3R?R((hj1wpx`1JVLdslS zTbsp*1F9vEg`1tba3HgibkEzvSt2?KqAQ2<{L52)1b>#zchvvZ3Qkq*;hUwobKwQXy(?)AwQ9lt6?^Y5Z%Nm zf>b@0m;bJ3%;|k`t!3+;1^(u7$q6Z`aE5$@<*La+UaH*U#yUv(^}$H4LFTK19ND-V z=s+nC=AB8I2B%AnGx>7i9#tHLN8;9)w1nii7?7HLr77!iahw>mYhW(rGuK)zc8g|| z3nJLtyLA*=MPz1w0KaL(CD_W*g7*YvHF~b-#q(_J04HqeGj+#(Ig?~zp~Ea(yK;3c zSgncm6eImG+{nQqeDU%<>}?p=2Wct|N>=F|5yrT){90)eeDRaV$)u{wkOXJn8bt%$ zreaxF4UzulyElT53Kd$QC4^)K|5E}JJFpQY{Ll9 z3u&X$_B3VQNu%@k59#T?l8LxRWLh6rzEIhzUYs-(7TW#*qy~;dL{6KOd_YHoQ(*_; zIGb^ZVRLjr@OW;lTpYsO!>QruP}Ie;G7z&c7FrOZjS^y`n|#Jt%Q1b%jg$cl%M8E9 zPL40Z-AZ&|qi?ff_RJbNc^w$qx0o?7;G0(ay*0PD!k^DK`!Q7*UbFosn#*aKyiM$TSd)n8vvu6!;~gcDGGg~ngHx=}$rz28eh z2CF^I^fYIoQ^B24$)_P7kd8WwpB&q}v)lX4bW)I}*0#1oKU8^5vXtTG*So(Kzy|Ax JskZQm{V!!c`r`lq literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-hdpi/nfc.png b/app/src/main/res/drawable-hdpi/nfc.png new file mode 100644 index 0000000000000000000000000000000000000000..74ac9d6de7c1f4d80ce1430ce7d504146d33e1ce GIT binary patch literal 2923 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-hdpi/placeholder.png b/app/src/main/res/drawable-hdpi/placeholder.png new file mode 100644 index 0000000000000000000000000000000000000000..5db1e40c870e2b8956c374a1d921dc27f19d9ed2 GIT binary patch literal 228 zcmeAS@N?(olHy`uVBq!ia0vp^Za}QT!3HFqFZ8SfQY`6?zK#qG8~eHcB(eheoCO|{ z#S9F52SAuH>slu#P*AGGHKHUqKdq!Zu_%=xATcwqM9KLZGSy zPZ!6K4Cl8O3>g^=1X?!yGXHCO!1Ba|)`{iiEj<#(sYhmLDj)NaG)z0yVHoVzGt(&P i%oM@oWyDGC{LWb2uu)L!hO-~gE(T9mKbLh*2~7Y@+et3~ literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-hdpi/plane.png b/app/src/main/res/drawable-hdpi/plane.png new file mode 100644 index 0000000000000000000000000000000000000000..a8050a4b82e5b6baf4e80de8f3f3b446e828cfa6 GIT binary patch literal 1295 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 O0000sc literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-hdpi/speed.png b/app/src/main/res/drawable-hdpi/speed.png new file mode 100644 index 0000000000000000000000000000000000000000..4e13c1a73bb012f7bfba3e3e2084a49bf659d763 GIT binary patch literal 5276 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 JE=M{N{tsfYL%RR~ literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-hdpi/startprogram.png b/app/src/main/res/drawable-hdpi/startprogram.png new file mode 100644 index 0000000000000000000000000000000000000000..e00a0e226c44d017effd903aa8429a66586c83e6 GIT binary patch literal 2683 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-hdpi/status_active.png b/app/src/main/res/drawable-hdpi/status_active.png new file mode 100644 index 0000000000000000000000000000000000000000..d4e9b4c703d7f742e57ee2dbab5554d34d152e70 GIT binary patch literal 412 zcmeAS@N?(olHy`uVBq!ia0vp^k|4~%1|*NXY)uAIjKx9jP7LeL$-D$|SkfJR9T^xl z_H+M9WCij$3p^r=85sBugD~Uq{1qucL5ULAh?3y^w370~qEv>0#LT=By}Z;C1rt33 zJ=4@yqg0@wyq+$OAs*gur`mEIGLUF9?ylf9_kVO=Pw(CV<{cHx?CJRrd|A{5FD?vb zEe|Z{u$wr=Eaw!0$f-X8a< z(TTC}lijMHnF>d0|mJDJ$v_PTFxrzn$4@{ZOPr#CDkIoFS3I->&y8UY^`Na$`VfQ zWnj9t>0O$`c^i8MF4k_|HMg1enttX31|EZ_tDnm{r-UW| D+BTz@ literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-hdpi/status_inactive.png b/app/src/main/res/drawable-hdpi/status_inactive.png new file mode 100644 index 0000000000000000000000000000000000000000..c1d0cfc94f2c5b7564bc2c5f152bf947e380bcd1 GIT binary patch literal 337 zcmeAS@N?(olHy`uVBq!ia0vp^k|4~%1|*NXY)uAIjKx9jP7LeL$-D$|SkfJR9T^xl z_H+M9WCij$3p^r=85sBugD~Uq{1qucL5ULAh?3y^w370~qEv>0#LT=By}Z;C1rt33 zJ=4@yqg0@pL!K^ z#O`Tb|EjIDko$1U!S5+iOmQ3TeVUi>LwMJRRG%LuDY7bO4AK@}vwgJ7ry)f+*^bBW ce{5h~kKCK*yA67#1AW8b>FVdQ&MBb@0O>=8H2?qr literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-hdpi/status_unable.png b/app/src/main/res/drawable-hdpi/status_unable.png new file mode 100644 index 0000000000000000000000000000000000000000..03978725f64ecb29587ec42262520d625da8c613 GIT binary patch literal 366 zcmeAS@N?(olHy`uVBq!ia0vp^k|4~%1|*NXY)uAIEa{HEjtmSN`?>!lvI6;>1s;*b z3=DjSK$uZf!>a)(C|TkfQ4*Y=R#Ki=l*&+$n3-3imzP?iV4`QBXJ~A~99;!e^xD(K zF~r0B?NmddCIbQ2;A+;~IR-KZKhB6daEd$PMkUkM1y4At7+;&tSIxL_rlrNMpCjB>>%Ny<_Fo^#@nXUI$~yU1MXvm{ z3szNd7xG*<%wDI|BL3%)$b;uC3yyA-{n8l!`(?%C;O`17HNE?@mK_S8!2NhVTYsk3 zG5O%9@n=p52^|F@`_?m`j-M|odnht*mGlp@aMTr~hcQ#q7 zlwa^~kWOm8kn~E<@%a3G+zfdgtcM#`N=vm_U2#_b<5A1-?16^hsn_>b0lm%O>FVdQ I&MBb@03wQ%vj6}9 literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-hdpi/talking.png b/app/src/main/res/drawable-hdpi/talking.png new file mode 100644 index 0000000000000000000000000000000000000000..e486e8b26cc767ffa189274795aa9a54569f4cf0 GIT binary patch literal 1644 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-hdpi/tune.png b/app/src/main/res/drawable-hdpi/tune.png new file mode 100644 index 0000000000000000000000000000000000000000..4759ec34a09f723e10891fb5d5824d6dd6c38e11 GIT binary patch literal 1473 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-hdpi/wait.png b/app/src/main/res/drawable-hdpi/wait.png new file mode 100644 index 0000000000000000000000000000000000000000..e20e14af1d6d85e9372aaabdeb2b34be55355600 GIT binary patch literal 3052 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 IM6N<$f_$rS7XSbN literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-ldpi/gears.png b/app/src/main/res/drawable-ldpi/gears.png new file mode 100644 index 0000000000000000000000000000000000000000..cc2dd79ba4df5e72df3fb38fb3bd9bfb523722ba GIT binary patch literal 867418 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%0Abl}4Mn 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%0DfL#dUnoDsb04KQa3pdEgQ@*iSNO)~$xCy~} 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%0D29sPp->2rP%Ez$6Yy1q;*EcPj>)mSV4 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�FH;USX1K=Poo&YJW|q=o{i`IJx*;i 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℘MO$T`XE5UG()e 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�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 z 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 >SgbtTgemk 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�)XerW&c*bJSvB=)8hJ@4n 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-ldpi/ic_launcher.png b/app/src/main/res/drawable-ldpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..36354a45e2561924dd3b5dd27f00cad9a1a16c7c GIT binary patch literal 1418 zcmV;51$Fv~P)9CO{X%3326QfQ#snq$K@*S!MhGS- zaS*eBE@D7R6`ih?3IuhQcP+GqG8iukVxg}T`rhOHU++^Mx~HR3g!m*UDNpY?|6k9& z_uO;Yw(bA^bai#zHa9o-lEdLpc|0DA*Xy-JB9Sl*pYaag&CbrA#@PRgBgJB|JnDA4 z+k(NMpNZ3255{0DeBg^18v@eP({sRXx3`2sAuiN!3(&ADxF*n)Cq$R6e*PK0h=Ewi zfFUa{uxW71GvW_NsC3A^N}RpoCV$FJi{uGLR%Hya5OY0HspI40#eqN|r1a~*oAJ^o z<4g4JZ!UVa!$uEktlXaISfIBDT=e`7VMpT4*i9ok@sZgZ7Nb%vck(LpoIA?~3X{ z8w_9p&@HSUjL6r|>%A*G1Ql2{wVX6iBdgpGYgaZ#p5C!)9rgG3kAek2yV%xq$=Ab42)$DfcEJ1dXIcjZ#EFLS$FA?fYLP@ z&4knG+%h0&Yqi=bY07rh*Vq5Zdf+Vsf;JeWMSW{!W#tFM!^0%CshbG|&5@B20s~k8 zbW>JV)+6oh?Gbj+@j+*eD<}K$wgvk3kBupesM6Bk@BHeL4p)M9PEO8IumI==X1CYY z)*8mf#`uay?*oU^T@K#VYi4{K0)!(7ebQU3&Hc+8=33CKtE(FXgJ9uLT7G{1DV$;ENcDg_wv94WYH>-3$ZpUyHj73JS`qtE+u%C-7f}n&A%w69#hm0^A3_ zh=Ev$iP%CT@!PAYns;VqW}Yl7D>JYD*i#XEe5F&GOU;hQF6ZOs3PMBzfvy&~=VnH^-7!R)ZG4DoKi7_(RS>_`;k YZy?(WPs*l}{{R3007*qoM6N<$g0hjeOaK4? literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-mdpi/cancel.png b/app/src/main/res/drawable-mdpi/cancel.png new file mode 100644 index 0000000000000000000000000000000000000000..8f141bddd5cce38e4b3819fdec1237c699495b8a GIT binary patch literal 380 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 E59N2f#Q*>R literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-mdpi/ic_launcher.png b/app/src/main/res/drawable-mdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..64e48c14189ef602e2616a06afd8652e68cb9f45 GIT binary patch literal 1859 zcmV-J2fX-+P)O&J_(zG>J#XjkST1`w$V~9=YlVZHYgvO-RXpK;dT$l(DpzIcEoMf_JzMb!! z-+Gv`b~!vEzzP&69NR=r-IVK5lJHJi;XcDr5c^?F?-3ZC%}|Dg@q;+wVRP8=T} zKioGx*XVG$oeW9KEuJMWX^jpi8`KCHkabVNhlhs`S}d0SrKKgRy=|wONgJ)C{5I{N z;#*ef88RRXGUIJXVoy)c9;4CN1f{;>!ZG027v=!&Hg4@^u80Pe`R))qgrDt$s!Vj#i((GDAO3*n&nTV3b%F zbVB!P;Wx0L3XdlwJK1@Toai&t{>#gQm)DPaOtk0@Zv}KhHyG}^=Xog6^C1;r?tge= zVa4F``c`MK?F~^z$WsQeXs2}ejH~kzof<4)0$bF1 z-_p|ZzRebXW16-t1@wL_DhwMjyCZIXU;ug!k1;y2!gZn7{_c zuyenrrsjyrWQr&V8&*6F$RD&sJ%WG@jNyD?V|RD=uWonXP)^xAq&2yvV*yGZJ1}}H z*0p=i<=+@FohBB8eGqJ51Zxm|Mn=XC-Z%nImEUL={qr4;W^#E+HEE}J_$(9aT0UkY zo9E8C%I6mt6|Z7N0wY+1oVT*FGIMrz*56piJ)m?}7*sSIpDA?e4>MgDw*|fLoe$hd z!3b8RGbgFl>JmQI`Wv?W?FyC>l}qa8j*gCNyzBWJwyuEz zIsMTM03%qzEH@yT&*78u&1=0H07kHaS#Chez`%e-?!fES05F0T%yI*^@u|;!zZd{k zFv|_t-rwKvzF(#gSiu}%Kv!4S;{D>pU{xBht+BCjO1_M)R|CKZR^=2*QK?in#LLR}S7)4l1HcAGuquxdI2b)#R#w(CIXNi> z4+!x-=2+J!=w%MrakP%70rSo!dcEb}fdAd=M)D;szyvlhf;CiRmYkE5^SMT&A*=7_OcJAD{5#Fwm zXbsMm@xZJ$Bd4rKINGy%Lg!V$02VNTEmBbL8-)}O+0x6)%N?VmqvUitgYz`3OJi_K zcLNA9m601VaQM$xUu_D`*p=S0O8>R9k2%96g^*eV16aT$Hm|5@Ml4S|jvYJpMRj$x z7jsV;=*tUw?pcKauQbgDw0X0AKFEMjLAx@5hi)){1x(9HY$b@4#U`#hPo6w^p|-YG z5)^7A;$;AIK__(Q=H^y`MKCQtKgx9r*Im5pwQ(;&rT1g%^#L583gly=5F6e}A!Eo0X9UFvzT}O`|J$3f% zSvwzPX>4pvI@V%+UabM*l24Ke+0X%9qUX1+=7K{$5*WgrhYlS&!oxaTQc^1ftyqUYJ+Fw0R4SI9HPJVsHK?mxl=t&(zlQSS&#|Y zLdT|rc-&NqWemgmDA&DNSy{Pxd3i%cMMX;m=f9^DB`W$s-Hfyc4Gj&ER;!gNp4HcG zQ0`9+bf&6?O3TU!-{4!wfGi<%tI!eO`(kkxNfGCg-CSN`kV0N|n|awAEhs3M`X;IKdZqvX002ovPDHLkV1kAnef0nU literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-mdpi/priority.png b/app/src/main/res/drawable-mdpi/priority.png new file mode 100644 index 0000000000000000000000000000000000000000..58b3852ef511704af2ab68811a10366bc14dd7cd GIT binary patch literal 140 zcmeAS@N?(olHy`uVBq!ia0vp^Dj>|k1|%Oc%$NbBf<0XvLn;{GUS?!tP~dTUD4Y1b z-O9;)we%GO9_9s0zyIL;5XdRopYfcTg+oBWp@D&siKQdXH}|Yr?(Oqh;?gIZ-(9V{ nxrQw&CelN8E0f#P + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable-xhdpi/ic_action_search.png b/app/src/main/res/drawable-xhdpi/ic_action_search.png new file mode 100644 index 0000000000000000000000000000000000000000..d699c6b37e0dcb1d636ebdd6733ab6d576d97ab5 GIT binary patch literal 3199 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 ReC-u>pr>W5S)<|b@_%^e3*P_$ literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-xhdpi/ic_launcher.png b/app/src/main/res/drawable-xhdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..28bf15ad95978209ce0d8b7dbe298c60e008ff15 GIT binary patch literal 3827 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable/ic_launcher_background.xml b/app/src/main/res/drawable/ic_launcher_background.xml new file mode 100644 index 0000000..07d5da9 --- /dev/null +++ b/app/src/main/res/drawable/ic_launcher_background.xml @@ -0,0 +1,170 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/src/main/res/layout/action_start_activity.xml b/app/src/main/res/layout/action_start_activity.xml new file mode 100644 index 0000000..f3f7296 --- /dev/null +++ b/app/src/main/res/layout/action_start_activity.xml @@ -0,0 +1,117 @@ + + + + + + + +