From 63a2277119558ed55de1098b5c05040ef9ff845d Mon Sep 17 00:00:00 2001 From: datang Date: Tue, 30 Aug 2022 17:00:44 +0800 Subject: [PATCH] new --- .idea/flutter_background_service_android.iml | 15 + .idea/libraries/Dart_Packages.xml | 236 +++++++++++++ .idea/libraries/Dart_SDK.xml | 27 ++ .idea/libraries/Flutter_Plugins.xml | 7 + .idea/modules.xml | 8 + .idea/vcs.xml | 6 + CHANGELOG.md | 180 ++++++++++ LICENSE | 25 ++ android/build.gradle | 37 ++ android/gradle.properties | 4 + .../gradle/wrapper/gradle-wrapper.properties | 6 + android/settings.gradle | 1 + android/src/main/AndroidManifest.xml | 32 ++ .../BackgroundService.java | 327 ++++++++++++++++++ .../BootReceiver.java | 30 ++ .../FlutterBackgroundServicePlugin.java | 183 ++++++++++ .../WatchdogReceiver.java | 20 ++ .../ic_bg_service_small.xml | 15 + .../res/drawable-hdpi/ic_bg_service_small.png | Bin 0 -> 416 bytes .../res/drawable-mdpi/ic_bg_service_small.png | Bin 0 -> 304 bytes .../drawable-xhdpi/ic_bg_service_small.png | Bin 0 -> 505 bytes .../drawable-xxhdpi/ic_bg_service_small.png | Bin 0 -> 1049 bytes flutter_background_service.iml | 19 + lib/flutter_background_service_android.dart | 186 ++++++++++ melos_flutter_background_service_android.iml | 29 ++ pubspec.yaml | 63 ++++ test/flutter_background_service_test.dart | 1 + 27 files changed, 1457 insertions(+) create mode 100644 .idea/flutter_background_service_android.iml create mode 100644 .idea/libraries/Dart_Packages.xml create mode 100644 .idea/libraries/Dart_SDK.xml create mode 100644 .idea/libraries/Flutter_Plugins.xml create mode 100644 .idea/modules.xml create mode 100644 .idea/vcs.xml create mode 100644 CHANGELOG.md create mode 100644 LICENSE create mode 100644 android/build.gradle create mode 100644 android/gradle.properties create mode 100644 android/gradle/wrapper/gradle-wrapper.properties create mode 100644 android/settings.gradle create mode 100644 android/src/main/AndroidManifest.xml create mode 100644 android/src/main/java/id/flutter/flutter_background_service/BackgroundService.java create mode 100644 android/src/main/java/id/flutter/flutter_background_service/BootReceiver.java create mode 100644 android/src/main/java/id/flutter/flutter_background_service/FlutterBackgroundServicePlugin.java create mode 100644 android/src/main/java/id/flutter/flutter_background_service/WatchdogReceiver.java create mode 100644 android/src/main/res/drawable-anydpi-v24/ic_bg_service_small.xml create mode 100644 android/src/main/res/drawable-hdpi/ic_bg_service_small.png create mode 100644 android/src/main/res/drawable-mdpi/ic_bg_service_small.png create mode 100644 android/src/main/res/drawable-xhdpi/ic_bg_service_small.png create mode 100644 android/src/main/res/drawable-xxhdpi/ic_bg_service_small.png create mode 100644 flutter_background_service.iml create mode 100644 lib/flutter_background_service_android.dart create mode 100644 melos_flutter_background_service_android.iml create mode 100644 pubspec.yaml create mode 100644 test/flutter_background_service_test.dart diff --git a/.idea/flutter_background_service_android.iml b/.idea/flutter_background_service_android.iml new file mode 100644 index 0000000..6155e93 --- /dev/null +++ b/.idea/flutter_background_service_android.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/libraries/Dart_Packages.xml b/.idea/libraries/Dart_Packages.xml new file mode 100644 index 0000000..460f26e --- /dev/null +++ b/.idea/libraries/Dart_Packages.xml @@ -0,0 +1,236 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/libraries/Dart_SDK.xml b/.idea/libraries/Dart_SDK.xml new file mode 100644 index 0000000..3dad229 --- /dev/null +++ b/.idea/libraries/Dart_SDK.xml @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/libraries/Flutter_Plugins.xml b/.idea/libraries/Flutter_Plugins.xml new file mode 100644 index 0000000..b0f6971 --- /dev/null +++ b/.idea/libraries/Flutter_Plugins.xml @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..aaa4363 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..94a25f7 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..5064f81 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,180 @@ +## 2.0.3 + + - **FIX**: wakelock not released. ([e427f3b7](https://github.com/ekasetiawans/flutter_background_service/commit/e427f3b70138ec26f9671c2617f9061f25eade6f)) + +## 2.0.2 + + - **FIX**: autoStartOnBootMode #160. ([16a785a3](https://github.com/ekasetiawans/flutter_background_service/commit/16a785a3cbcb4226321ddddf681b6554196fa4db)) + +## 2.0.1 + + - **FIX**: release wakelock. ([c0830250](https://github.com/ekasetiawans/flutter_background_service/commit/c0830250b90a1ba6e2543a1bb25a13fba59a56b7)) + +## 2.0.0 + + - Graduate package to a stable release. See pre-releases prior to this version for changelog entries. + +## 2.0.0-dev.0 + +> Note: This release has breaking changes. + + - **BREAKING** **FEAT**: implement new concept. ([c8ce9c0b](https://github.com/ekasetiawans/flutter_background_service/commit/c8ce9c0bab82137dea031af124b84510286661f7)) + +## 1.0.2 + + - **DOCS**: readme link. ([1479b91c](https://github.com/ekasetiawans/flutter_background_service/commit/1479b91cd80d637335de1314a528bcf51ebb7c0f)) + +## 1.0.1 + + - **DOCS**: update README. ([fbf5e0ab](https://github.com/ekasetiawans/flutter_background_service/commit/fbf5e0abeeb9296ba32361b8af0a298ee9e71527)) + +## 0.0.2 + + - **FEAT**: migrate to plugin platform interface. ([70e08ff0](https://github.com/ekasetiawans/flutter_background_service/commit/70e08ff03232c31946cc8eb7896f69c830f23322)) + +## 0.0.1+3 + + - **FIX**: errors. ([13a6f841](https://github.com/ekasetiawans/flutter_background_service/commit/13a6f841f5d677ceb0010e8ba1bf9d7af53adbcf)) + +## 0.0.1+2 + + - Update a dependency to the latest release. + +## 0.0.1+1 + + - **REFACTOR**: initialize melos. + +## 0.2.6 +* FIX: (Android) flutter initialization +## 0.2.5 +* FIX: (iOS) using other plugins +## 0.2.4 +* FIX: (Android) run service background when charger not connected and screen lock (#92) +## 0.2.3 +* ADDED: Using `BGTaskScheduler` on iOS 13. See readme for configuration. +## 0.2.2 +* ADDED: `autoStart` to `IosConfiguration` +## 0.2.1 +* UPDATE README +* UPDATE: Flutter Version Constraint +## 0.2.0+1 +* UPDATE README + +## 0.2.0 +* [BREAKING]: FlutterBackgroundService.initialize renamed to FlutterBackgroundService.configure +* [BREAKING]: use FlutterBackgroundService.start to start or restart after you call stopService. +* [ADDED]: IOS Background fetch is now supported you have to enable background fetch from xcode. +## 0.1.7 + +* Fix : cannot start service on android 12 +* Fix : not started on boot completed +## 0.1.6 + +* Android 12 Compatibility Changes +## 0.1.5 + +* Rollback foreground notification importance +## 0.1.4 + +* fixes UnsatisfiedLinkError when running as foreground service with autostart #32 +## 0.1.3 + +* Fix notification not showing on android 7 and prior (Issue #26) +## 0.1.2 + +* Open app from notification (Issue #30) +## 0.1.1 + +* Fix #29 (DartVM not terminated when service stop) + +## 0.1.0 + +* Bump flutter 2 + +## 0.1.0-nullsafety.2 + +* Fix #23 + +## 0.1.0-nullsafety.1 + +* Added isServiceRunning on iOS (issue #19) + +## 0.1.0-nullsafety.0 + +* Added support to nullsafety + +## 0.0.1+18 + +* Added stopService Method(Currently Works on Android Only). + +## 0.0.1+17 + +* Add preference autoStart on Boot, default is true. + +## 0.0.1+16 + +* Set Foreground Mode to false will remove notification. BugFix #4. + +## 0.0.1+15 + +* Add ability to change Background or Foreground mode (Android Only) + +## 0.0.1+14 + +* Bugfix BootReceiver + +## 0.0.1+13 + +* Update example for iOS support. + +## 0.0.1+12 + +* Start service immediately after initialize + +## 0.0.1+11 + +* iOS + +## 0.0.1+10 + +* bug fix + +## 0.0.1+9 + +* bug fix + +## 0.0.1+8 + +* bug fix + +## 0.0.1+7 + +* Add ability to send data from UI to Service + +## 0.0.1+6 + +* Improve stability + +## 0.0.1+5 + +* Add ability to send data from service to UI + +## 0.0.1+4 + +* Update README + +## 0.0.1+3 + +* Add ability to change notification info (Android foreground service) + +## 0.0.1+2 + +* Fix android missing plugin implementation + +## 0.0.1+1 + +* Fix android build + +## 0.0.1 + +* TODO: Describe initial release. \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..6f3b2ac --- /dev/null +++ b/LICENSE @@ -0,0 +1,25 @@ +Copyright 2017 The Chromium Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google Inc. nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/android/build.gradle b/android/build.gradle new file mode 100644 index 0000000..3459b08 --- /dev/null +++ b/android/build.gradle @@ -0,0 +1,37 @@ +group 'id.flutter.flutter_background_service' +version '1.0' + +buildscript { + repositories { + google() + jcenter() + } + + dependencies { + classpath 'com.android.tools.build:gradle:4.1.0' + } +} + +rootProject.allprojects { + repositories { + google() + jcenter() + } +} + +apply plugin: 'com.android.library' + +android { + compileSdkVersion 31 + + defaultConfig { + minSdkVersion 16 + } + lintOptions { + disable 'InvalidPackage' + } +} + +dependencies { + implementation 'androidx.localbroadcastmanager:localbroadcastmanager:1.0.0' +} \ No newline at end of file diff --git a/android/gradle.properties b/android/gradle.properties new file mode 100644 index 0000000..38c8d45 --- /dev/null +++ b/android/gradle.properties @@ -0,0 +1,4 @@ +org.gradle.jvmargs=-Xmx1536M +android.enableR8=true +android.useAndroidX=true +android.enableJetifier=true diff --git a/android/gradle/wrapper/gradle-wrapper.properties b/android/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..bc6a58a --- /dev/null +++ b/android/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,6 @@ +#Fri Jun 23 08:50:38 CEST 2017 +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-6.7-all.zip diff --git a/android/settings.gradle b/android/settings.gradle new file mode 100644 index 0000000..1f1100c --- /dev/null +++ b/android/settings.gradle @@ -0,0 +1 @@ +rootProject.name = 'flutter_background_service' diff --git a/android/src/main/AndroidManifest.xml b/android/src/main/AndroidManifest.xml new file mode 100644 index 0000000..e0d0392 --- /dev/null +++ b/android/src/main/AndroidManifest.xml @@ -0,0 +1,32 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/android/src/main/java/id/flutter/flutter_background_service/BackgroundService.java b/android/src/main/java/id/flutter/flutter_background_service/BackgroundService.java new file mode 100644 index 0000000..dbe12dd --- /dev/null +++ b/android/src/main/java/id/flutter/flutter_background_service/BackgroundService.java @@ -0,0 +1,327 @@ +package id.flutter.flutter_background_service; + +import static android.os.Build.VERSION.SDK_INT; + +import android.app.AlarmManager; +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.content.SharedPreferences; +import android.os.Build; +import android.os.IBinder; +import android.os.PowerManager; +import android.os.PowerManager.WakeLock; +import android.util.Log; +import androidx.annotation.NonNull; +import androidx.core.app.AlarmManagerCompat; +import androidx.core.app.NotificationCompat; +import androidx.localbroadcastmanager.content.LocalBroadcastManager; + +import org.json.JSONException; +import org.json.JSONObject; + +import java.util.concurrent.atomic.AtomicBoolean; +import java.lang.UnsatisfiedLinkError; + +import io.flutter.FlutterInjector; +import io.flutter.embedding.engine.FlutterEngine; +import io.flutter.embedding.engine.dart.DartExecutor; +import io.flutter.embedding.engine.loader.FlutterLoader; +import io.flutter.plugin.common.JSONMethodCodec; +import io.flutter.plugin.common.MethodCall; +import io.flutter.plugin.common.MethodChannel; +import io.flutter.view.FlutterCallbackInformation; + +public class BackgroundService extends Service implements MethodChannel.MethodCallHandler { + private static final String TAG = "BackgroundService"; + private FlutterEngine backgroundEngine; + private MethodChannel methodChannel; + private DartExecutor.DartCallback dartCallback; + private boolean isManuallyStopped = false; + + String notificationTitle = "短信帮手正在后台运行"; + String notificationContent = "Running"; + private static final String LOCK_NAME = BackgroundService.class.getName() + + ".Lock"; + public static volatile WakeLock lockStatic = null; // notice static + + synchronized public static PowerManager.WakeLock getLock(Context context) { + if (lockStatic == null) { + PowerManager mgr = (PowerManager) context + .getSystemService(Context.POWER_SERVICE); + lockStatic = mgr.newWakeLock(PowerManager.FULL_WAKE_LOCK, + LOCK_NAME); + lockStatic.setReferenceCounted(true); + } + return (lockStatic); + } + + @Override + public IBinder onBind(Intent intent) { + return null; + } + + public static void enqueue(Context context) { + Intent intent = new Intent(context, WatchdogReceiver.class); + AlarmManager manager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE); + + int flags = PendingIntent.FLAG_UPDATE_CURRENT; + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) { + flags |= PendingIntent.FLAG_MUTABLE; + } + + PendingIntent pIntent = PendingIntent.getBroadcast(context, 111, intent, flags); + AlarmManagerCompat.setAndAllowWhileIdle(manager, AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + 5000, pIntent); + } + + public void setAutoStartOnBootMode(boolean value) { + SharedPreferences pref = getSharedPreferences("id.flutter.background_service", MODE_PRIVATE); + pref.edit().putBoolean("auto_start_on_boot", value).apply(); + } + + public static boolean isAutoStartOnBootMode(Context context) { + SharedPreferences pref = context.getSharedPreferences("id.flutter.background_service", MODE_PRIVATE); + return pref.getBoolean("auto_start_on_boot", true); + } + + public void setForegroundServiceMode(boolean value) { + SharedPreferences pref = getSharedPreferences("id.flutter.background_service", MODE_PRIVATE); + pref.edit().putBoolean("is_foreground", value).apply(); + } + + public static boolean isForegroundService(Context context) { + SharedPreferences pref = context.getSharedPreferences("id.flutter.background_service", MODE_PRIVATE); + return pref.getBoolean("is_foreground", true); + } + + public void setManuallyStopped(boolean value) { + SharedPreferences pref = getSharedPreferences("id.flutter.background_service", MODE_PRIVATE); + pref.edit().putBoolean("is_manually_stopped", value).apply(); + } + + public static boolean isManuallyStopped(Context context) { + SharedPreferences pref = context.getSharedPreferences("id.flutter.background_service", MODE_PRIVATE); + return pref.getBoolean("is_manually_stopped", false); + } + + @Override + public void onCreate() { + super.onCreate(); + createNotificationChannel(); + notificationContent = "点击即可查看更多选项。"; + updateNotificationInfo(); + } + + @Override + public void onDestroy() { + if (!isManuallyStopped) { + enqueue(this); + } else { + setManuallyStopped(true); + } + stopForeground(true); + isRunning.set(false); + + if (backgroundEngine != null) { + backgroundEngine.getServiceControlSurface().detachFromService(); + backgroundEngine.destroy(); + backgroundEngine = null; + } + + methodChannel = null; + dartCallback = null; + super.onDestroy(); + } + + private void createNotificationChannel() { + if (SDK_INT >= Build.VERSION_CODES.O) { + CharSequence name = "Background Service"; + String description = "Executing process in background"; + + int importance = NotificationManager.IMPORTANCE_LOW; + NotificationChannel channel = new NotificationChannel("FOREGROUND_DEFAULT", name, importance); + channel.setDescription(description); + + NotificationManager notificationManager = getSystemService(NotificationManager.class); + notificationManager.createNotificationChannel(channel); + } + } + + protected void updateNotificationInfo() { + if (isForegroundService(this)) { + + String packageName = getApplicationContext().getPackageName(); + Intent i = getPackageManager().getLaunchIntentForPackage(packageName); + + int flags = PendingIntent.FLAG_CANCEL_CURRENT; + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) { + flags |= PendingIntent.FLAG_MUTABLE; + } + + PendingIntent pi = PendingIntent.getActivity(BackgroundService.this, 99778, i, flags); + + NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this, "FOREGROUND_DEFAULT") + .setSmallIcon(R.drawable.ic_bg_service_small) + .setAutoCancel(true) + .setOngoing(true) + .setContentTitle(notificationTitle) + .setContentText(notificationContent) + .setContentIntent(pi); + + startForeground(99778, mBuilder.build()); + } + } + + @Override + public int onStartCommand(Intent intent, int flags, int startId) { + setManuallyStopped(false); + enqueue(this); + runService(); + + return START_STICKY; + } + + AtomicBoolean isRunning = new AtomicBoolean(false); + + private void runService() { + try { + Log.d(TAG, "runService"); + if (isRunning.get() || (backgroundEngine != null && !backgroundEngine.getDartExecutor().isExecutingDart())) + return; + + if (lockStatic == null){ + getLock(getApplicationContext()).acquire(10*60*1000L /*10 minutes*/); + } + + updateNotificationInfo(); + + SharedPreferences pref = getSharedPreferences("id.flutter.background_service", MODE_PRIVATE); + long entrypointHandle = pref.getLong("entrypoint_handle", 0); + + FlutterLoader flutterLoader = FlutterInjector.instance().flutterLoader(); + // initialize flutter if it's not initialized yet + if (!flutterLoader.initialized()) { + flutterLoader.startInitialization(getApplicationContext()); + } + + flutterLoader.ensureInitializationComplete(getApplicationContext(), null); + FlutterCallbackInformation callback = FlutterCallbackInformation.lookupCallbackInformation(entrypointHandle); + if (callback == null) { + Log.e(TAG, "callback handle not found"); + return; + } + + isRunning.set(true); + backgroundEngine = new FlutterEngine(this); + backgroundEngine.getServiceControlSurface().attachToService(BackgroundService.this, null, isForegroundService(this)); + + methodChannel = new MethodChannel(backgroundEngine.getDartExecutor().getBinaryMessenger(), "id.flutter/background_service_android_bg", JSONMethodCodec.INSTANCE); + methodChannel.setMethodCallHandler(this); + + dartCallback = new DartExecutor.DartCallback(getAssets(), flutterLoader.findAppBundlePath(), callback); + backgroundEngine.getDartExecutor().executeDartCallback(dartCallback); + } catch (UnsatisfiedLinkError e) { + notificationContent = "Error " + e.getMessage(); + updateNotificationInfo(); + + Log.w(TAG, "UnsatisfiedLinkError: After a reboot this may happen for a short period and it is ok to ignore then!" + e.getMessage()); + } + } + + public void receiveData(JSONObject data) { + if (methodChannel != null) { + try { + methodChannel.invokeMethod("onReceiveData", data); + } catch (Exception e) { + e.printStackTrace(); + } + } + } + + @Override + public void onMethodCall(@NonNull MethodCall call, @NonNull MethodChannel.Result result) { + String method = call.method; + + try { + if (method.equalsIgnoreCase("getHandler")) { + SharedPreferences pref = getSharedPreferences("id.flutter.background_service", MODE_PRIVATE); + long backgroundHandle = pref.getLong("background_handle", 0); + result.success(backgroundHandle); + + if (lockStatic != null) { + lockStatic.release(); + lockStatic = null; + } + return; + } + + if (method.equalsIgnoreCase("setNotificationInfo")) { + JSONObject arg = (JSONObject) call.arguments; + if (arg.has("title")) { + notificationTitle = arg.getString("title"); + notificationContent = arg.getString("content"); + updateNotificationInfo(); + result.success(true); + } + return; + } + + if (method.equalsIgnoreCase("setAutoStartOnBootMode")) { + JSONObject arg = (JSONObject) call.arguments; + boolean value = arg.getBoolean("value"); + setAutoStartOnBootMode(value); + result.success(true); + return; + } + + if (method.equalsIgnoreCase("setForegroundMode")) { + JSONObject arg = (JSONObject) call.arguments; + boolean value = arg.getBoolean("value"); + setForegroundServiceMode(value); + if (value) { + updateNotificationInfo(); + } else { + stopForeground(true); + } + + result.success(true); + return; + } + + if (method.equalsIgnoreCase("stopService")) { + isManuallyStopped = true; + Intent intent = new Intent(this, WatchdogReceiver.class); + + int flags = PendingIntent.FLAG_CANCEL_CURRENT; + if (SDK_INT >= Build.VERSION_CODES.S) { + flags |= PendingIntent.FLAG_MUTABLE; + } + + PendingIntent pi = PendingIntent.getBroadcast(getApplicationContext(), 111, intent, flags); + + AlarmManager alarmManager = (AlarmManager) getSystemService(ALARM_SERVICE); + alarmManager.cancel(pi); + stopSelf(); + result.success(true); + return; + } + + if (method.equalsIgnoreCase("sendData")) { + LocalBroadcastManager manager = LocalBroadcastManager.getInstance(this); + Intent intent = new Intent("id.flutter/background_service"); + intent.putExtra("data", call.arguments.toString()); + manager.sendBroadcast(intent); + result.success(true); + return; + } + } catch (JSONException e) { + Log.e(TAG, e.getMessage()); + e.printStackTrace(); + } + + result.notImplemented(); + } +} diff --git a/android/src/main/java/id/flutter/flutter_background_service/BootReceiver.java b/android/src/main/java/id/flutter/flutter_background_service/BootReceiver.java new file mode 100644 index 0000000..7059485 --- /dev/null +++ b/android/src/main/java/id/flutter/flutter_background_service/BootReceiver.java @@ -0,0 +1,30 @@ +package id.flutter.flutter_background_service; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.SharedPreferences; + +import androidx.core.content.ContextCompat; + +import static android.content.Context.MODE_PRIVATE; + + +public class BootReceiver extends BroadcastReceiver { + @Override + public void onReceive(Context context, Intent intent) { + SharedPreferences pref = context.getSharedPreferences("id.flutter.background_service", MODE_PRIVATE); + boolean autoStart = pref.getBoolean("auto_start_on_boot",true); + if(autoStart) { + if (BackgroundService.lockStatic == null){ + BackgroundService.getLock(context).acquire(10*60*1000L /*10 minutes*/); + } + + if (BackgroundService.isForegroundService(context)) { + ContextCompat.startForegroundService(context, new Intent(context, BackgroundService.class)); + } else { + context.startService(new Intent(context, BackgroundService.class)); + } + } + } +} diff --git a/android/src/main/java/id/flutter/flutter_background_service/FlutterBackgroundServicePlugin.java b/android/src/main/java/id/flutter/flutter_background_service/FlutterBackgroundServicePlugin.java new file mode 100644 index 0000000..cb8f4bc --- /dev/null +++ b/android/src/main/java/id/flutter/flutter_background_service/FlutterBackgroundServicePlugin.java @@ -0,0 +1,183 @@ +package id.flutter.flutter_background_service; + +import static android.content.Context.MODE_PRIVATE; + +import android.app.ActivityManager; +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.SharedPreferences; +import android.util.Log; + +import androidx.annotation.NonNull; +import androidx.core.content.ContextCompat; +import androidx.localbroadcastmanager.content.LocalBroadcastManager; + +import org.json.JSONException; +import org.json.JSONObject; + +import java.util.ArrayList; +import java.util.List; + +import io.flutter.embedding.engine.plugins.FlutterPlugin; +import io.flutter.embedding.engine.plugins.service.ServiceAware; +import io.flutter.embedding.engine.plugins.service.ServicePluginBinding; +import io.flutter.plugin.common.MethodCall; +import io.flutter.plugin.common.MethodChannel; +import io.flutter.plugin.common.MethodChannel.MethodCallHandler; +import io.flutter.plugin.common.MethodChannel.Result; +import io.flutter.plugin.common.PluginRegistry.Registrar; +import io.flutter.plugin.common.JSONMethodCodec; + +/** FlutterBackgroundServicePlugin */ +public class FlutterBackgroundServicePlugin extends BroadcastReceiver implements FlutterPlugin, MethodCallHandler, ServiceAware { + private static final String TAG = "BackgroundServicePlugin"; + private static final List _instances = new ArrayList<>(); + + public FlutterBackgroundServicePlugin() { + _instances.add(this); + } + + private MethodChannel channel; + private Context context; + private BackgroundService service; + + @Override + public void onAttachedToEngine(@NonNull FlutterPluginBinding flutterPluginBinding) { + this.context = flutterPluginBinding.getApplicationContext(); + LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(this.context); + localBroadcastManager.registerReceiver(this, new IntentFilter("id.flutter/background_service")); + + channel = new MethodChannel(flutterPluginBinding.getBinaryMessenger(), "id.flutter/background_service_android", JSONMethodCodec.INSTANCE); + channel.setMethodCallHandler(this); + } + + public static void registerWith(Registrar registrar) { + LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(registrar.context()); + final FlutterBackgroundServicePlugin plugin = new FlutterBackgroundServicePlugin(); + localBroadcastManager.registerReceiver(plugin, new IntentFilter("id.flutter/background_service")); + + final MethodChannel channel = new MethodChannel(registrar.messenger(), "id.flutter/background_service_android", JSONMethodCodec.INSTANCE); + channel.setMethodCallHandler(plugin); + plugin.channel = channel; + } + + private static void configure(Context context, long entrypointHandle, long backgroundHandle, boolean isForeground, boolean autoStartOnBoot) { + SharedPreferences pref = context.getSharedPreferences("id.flutter.background_service", MODE_PRIVATE); + pref.edit() + .putLong("entrypoint_handle", entrypointHandle) + .putLong("background_handle", backgroundHandle) + .putBoolean("is_foreground", isForeground) + .putBoolean("auto_start_on_boot", autoStartOnBoot) + .apply(); + } + + private void start() { + BackgroundService.enqueue(context); + boolean isForeground = BackgroundService.isForegroundService(context); + Intent intent = new Intent(context, BackgroundService.class); + if (isForeground) { + ContextCompat.startForegroundService(context, intent); + } else { + context.startService(intent); + } + } + + @Override + public void onMethodCall(@NonNull MethodCall call, @NonNull Result result) { + String method = call.method; + JSONObject arg = (JSONObject) call.arguments; + + try { + if ("configure".equals(method)) { + long entrypointHandle = arg.getLong("entrypoint_handle"); + long backgroundHandle = arg.getLong("background_handle"); + boolean isForeground = arg.getBoolean("is_foreground_mode"); + boolean autoStartOnBoot = arg.getBoolean("auto_start_on_boot"); + + configure(context, entrypointHandle, backgroundHandle, isForeground, autoStartOnBoot); + if (autoStartOnBoot) { + start(); + } + + result.success(true); + return; + } + + if ("start".equals(method)) { + start(); + result.success(true); + return; + } + + if (method.equalsIgnoreCase("sendData")) { + for (FlutterBackgroundServicePlugin plugin : _instances) { + if (plugin.service != null) { + plugin.service.receiveData((JSONObject) call.arguments); + break; + } + } + + result.success(true); + return; + } + + if (method.equalsIgnoreCase("isServiceRunning")) { + ActivityManager manager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE); + for (ActivityManager.RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) { + if (BackgroundService.class.getName().equals(service.service.getClassName())) { + result.success(true); + return; + } + } + result.success(false); + return; + } + + result.notImplemented(); + } catch (Exception e) { + result.error("100", "Failed read arguments", null); + } + } + + @Override + public void onDetachedFromEngine(@NonNull FlutterPluginBinding binding) { + channel.setMethodCallHandler(null); + + LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(this.context); + localBroadcastManager.unregisterReceiver(this); + } + + @Override + public void onReceive(Context context, Intent intent) { + if (intent.getAction() == null) return; + + if (intent.getAction().equalsIgnoreCase("id.flutter/background_service")) { + String data = intent.getStringExtra("data"); + try { + JSONObject jData = new JSONObject(data); + if (channel != null) { + channel.invokeMethod("onReceiveData", jData); + } + } catch (JSONException e) { + e.printStackTrace(); + } catch (Exception e) { + e.printStackTrace(); + } + } + } + + @Override + public void onAttachedToService(@NonNull ServicePluginBinding binding) { + Log.d(TAG, "onAttachedToService"); + + this.service = (BackgroundService) binding.getService(); + } + + @Override + public void onDetachedFromService() { + this.service = null; + Log.d(TAG, "onDetachedFromService"); + } +} diff --git a/android/src/main/java/id/flutter/flutter_background_service/WatchdogReceiver.java b/android/src/main/java/id/flutter/flutter_background_service/WatchdogReceiver.java new file mode 100644 index 0000000..043558a --- /dev/null +++ b/android/src/main/java/id/flutter/flutter_background_service/WatchdogReceiver.java @@ -0,0 +1,20 @@ +package id.flutter.flutter_background_service; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; + +import androidx.core.content.ContextCompat; + +public class WatchdogReceiver extends BroadcastReceiver { + @Override + public void onReceive(Context context, Intent intent) { + if(!BackgroundService.isManuallyStopped(context)) { + if (BackgroundService.isForegroundService(context)) { + ContextCompat.startForegroundService(context, new Intent(context, BackgroundService.class)); + } else { + context.startService(new Intent(context, BackgroundService.class)); + } + } + } +} diff --git a/android/src/main/res/drawable-anydpi-v24/ic_bg_service_small.xml b/android/src/main/res/drawable-anydpi-v24/ic_bg_service_small.xml new file mode 100644 index 0000000..39d15ef --- /dev/null +++ b/android/src/main/res/drawable-anydpi-v24/ic_bg_service_small.xml @@ -0,0 +1,15 @@ + + + + + diff --git a/android/src/main/res/drawable-hdpi/ic_bg_service_small.png b/android/src/main/res/drawable-hdpi/ic_bg_service_small.png new file mode 100644 index 0000000000000000000000000000000000000000..4f4a5c8fe5afd0b87cf329db5f45e98b014baccd GIT binary patch literal 416 zcmV;R0bl-!P)Shp?=)^AeqZL>z}?Bp_Z9;0}CgDuj0S z>Ff(+rE@_}LXq$)2c+H-BpC=x^8)+mmIBkme(HV`%z6*n@tEdnLNE;+qbdY+KY}I% zVO@77fWcopU9grqg(obZ007@voi3aB_DMte=HG( z+a_8r&>W@|7(r?-P&Iq!%7mF>LsxP&2zB&xY#vTNYoU%_#YT=H@Zw{=5RT4}GLV^+ zFA<7PlR6l$+!%gO4xn~xXXRSK~ zW(AUZO>|qpl$2^pDsRUBIcBAK{uoI&16hfd#w53B2GlP&-Z+8*Y)-gEK0ywf5>|d4|3H^2#|+!x9CO50 z;tow1V1R8=`{GUE$5ZY+%)aM3!!?g_ZwLcSoTia=MGelOC5LgLxdC3tBRPyabW_a# z$;=CTpr zl;k<&ifhU9$eCL6wbTj&C|VDevRs@(z0te)^LPX2zMa(?$%CE%0000Zs~h)mhb5*Bvx+AbQY5XOg`pXpIzvA7r08>4_;8;ra9b0X_s3 z>7%y89cUpiNwY|#muNAFpH$r-4cbp7{y^a1{?Am@afSL$vy(fGW8<-VOmm{1l$nFSBngVy`DOgfKb1e#2JcF33w&n5s;TQ z`3HkMOBvw2J->Jd)rqaP5gyBAd~N6|8cw|AD4jwF#JEPSu}~5lM-K9%#F6xxN>3>dgQWV#~0!sH1~7&6-6F@00000NkvXXu0mjf@j>9! literal 0 HcmV?d00001 diff --git a/android/src/main/res/drawable-xxhdpi/ic_bg_service_small.png b/android/src/main/res/drawable-xxhdpi/ic_bg_service_small.png new file mode 100644 index 0000000000000000000000000000000000000000..6c378c6654faa79f54b10f6581f390b222771056 GIT binary patch literal 1049 zcmV+!1m^pRP)}P=QV7C~f^Jd|QJM8nk#>QSLg^v2ASi-vU_KNX zg&K6V5bT0cQ9guSD7rxRdqnm1AI=7c!#SRv-PxJh_59)gAnwjL{@mS}`Q{tLh$*I+ zViF@FN{92|)o>Mj1a5@y!Od_R1(fV(2&3Racr$zmz63ua4*3Pd7!yP}d?r z$L?bl&R|7wZo=t7YrfwSW8dO=dKM^vvn?q8MEINRZygVyeG)sy_Qqxf#U4%ax0#vd z@&LLfsZ%fE@j-Eu;HQdS??F6(WbBLIVHtvuxT=!=?L2ULOX$#r&=CVaS1O!R?B-pZ zx~cPUkC2!%;lBz2&ENr)AsNn4Qo94oM$0%JK$$Le&IMMXNDFtWpiu zdP{i$r3mf-OV!4QiNjv4FN)#(f)niIpG8ga*_>uzgg6&9czPP`?qGWP3T^L0~p)cZ<+&KS`NEE6Q>L zD8a#`E3K1ucWMHsO+aPL7)02R1-tbpZ+!qp{aTew$;kMmI(2U99Sf?lz3Pp$@V*t### zkRb}36aBC07Ovl`0ibL{mduqn+cRsmc>OEIaOSBxH8{?~HL6FiT{<6FR$V?*W#}%p zHd6#=jo}5Mqn{;%Ve7`JUV)P#84f!^on&}L=Oj T-*Zo*00000NkvXXu0mjfV9D + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/lib/flutter_background_service_android.dart b/lib/flutter_background_service_android.dart new file mode 100644 index 0000000..92d5a47 --- /dev/null +++ b/lib/flutter_background_service_android.dart @@ -0,0 +1,186 @@ +import 'dart:async'; +import 'dart:ui'; + +import 'package:flutter/material.dart'; +import 'package:flutter/services.dart'; +import 'package:flutter_background_service_platform_interface/flutter_background_service_platform_interface.dart'; + +Future _entrypoint() async { + WidgetsFlutterBinding.ensureInitialized(); + final service = AndroidServiceInstance._(); + final int handle = await service._getHandler(); + final callbackHandle = CallbackHandle.fromRawHandle(handle); + final onStart = PluginUtilities.getCallbackFromHandle(callbackHandle); + if (onStart != null) { + onStart(service); + } +} + +class FlutterBackgroundServiceAndroid extends FlutterBackgroundServicePlatform { + /// Registers this class as the default instance of [FlutterBackgroundServicePlatform]. + static void registerWith() { + FlutterBackgroundServicePlatform.instance = + FlutterBackgroundServiceAndroid(); + } + + static const MethodChannel _channel = const MethodChannel( + 'id.flutter/background_service_android', + JSONMethodCodec(), + ); + + Future _handle(MethodCall call) async { + switch (call.method) { + case "onReceiveData": + _controller.sink.add(call.arguments); + break; + default: + } + + return true; + } + + Future start() async { + final result = await _channel.invokeMethod('start'); + return result ?? false; + } + + Future configure({ + required IosConfiguration iosConfiguration, + required AndroidConfiguration androidConfiguration, + }) async { + _channel.setMethodCallHandler(_handle); + + final CallbackHandle? entryPointHandle = + PluginUtilities.getCallbackHandle(_entrypoint); + + final CallbackHandle? handle = + PluginUtilities.getCallbackHandle(androidConfiguration.onStart); + + if (entryPointHandle == null || handle == null) { + return false; + } + + final result = await _channel.invokeMethod( + "configure", + { + "entrypoint_handle": entryPointHandle.toRawHandle(), + "background_handle": handle.toRawHandle(), + "is_foreground_mode": androidConfiguration.isForegroundMode, + "auto_start_on_boot": androidConfiguration.autoStart, + }, + ); + + return result ?? false; + } + + Future isServiceRunning() async { + var result = await _channel.invokeMethod("isServiceRunning"); + return result ?? false; + } + + final _controller = StreamController.broadcast(sync: true); + + void dispose() { + _controller.close(); + } + + @override + void invoke(String method, [Map? args]) { + _channel.invokeMethod("sendData", { + 'method': method, + 'args': args, + }); + } + + @override + Stream?> on(String method) { + return _controller.stream.transform( + StreamTransformer.fromHandlers( + handleData: (data, sink) { + if (data['method'] == method) { + sink.add(data['args']); + } + }, + ), + ); + } +} + +class AndroidServiceInstance extends ServiceInstance { + static const MethodChannel _channel = const MethodChannel( + 'id.flutter/background_service_android_bg', + JSONMethodCodec(), + ); + + AndroidServiceInstance._() { + _channel.setMethodCallHandler(_handleMethodCall); + } + + final _controller = StreamController.broadcast(sync: true); + Future _handleMethodCall(MethodCall call) async { + switch (call.method) { + case "onReceiveData": + _controller.sink.add(call.arguments); + break; + default: + } + } + + @override + void invoke(String method, [Map? args]) { + _channel.invokeMethod('sendData', { + 'method': method, + 'args': args, + }); + } + + @override + Future stopSelf() async { + await _channel.invokeMethod("stopService"); + } + + @override + Stream?> on(String method) { + return _controller.stream.transform( + StreamTransformer.fromHandlers( + handleData: (data, sink) { + if (data['method'] == method) { + sink.add(data['args']); + } + }, + ), + ); + } + + Future setForegroundNotificationInfo({ + required String title, + required String content, + }) async { + await _channel.invokeMethod("setNotificationInfo", { + "title": title, + "content": content, + }); + } + + Future setAsForegroundService() async { + await _channel.invokeMethod("setForegroundMode", { + 'value': true, + }); + } + + Future setAsBackgroundService() async { + await _channel.invokeMethod("setForegroundMode", { + 'value': false, + }); + } + + Future _getHandler() async { + return await _channel.invokeMethod('getHandler'); + } + + Future setAutoStartOnBootMode(bool value) async { + await _channel.invokeMethod("setAutoStartOnBootMode", { + "value": value, + }); + } +} diff --git a/melos_flutter_background_service_android.iml b/melos_flutter_background_service_android.iml new file mode 100644 index 0000000..9fc8ce7 --- /dev/null +++ b/melos_flutter_background_service_android.iml @@ -0,0 +1,29 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pubspec.yaml b/pubspec.yaml new file mode 100644 index 0000000..8785694 --- /dev/null +++ b/pubspec.yaml @@ -0,0 +1,63 @@ +name: flutter_background_service_android +description: A flutter plugin for executing dart code continously even application closed. +version: 2.0.3 +repository: https://github.com/ekasetiawans/flutter_background_service + +environment: + sdk: ">=2.12.0 <3.0.0" + flutter: ">=2.0.0" + +dependencies: + flutter: + sdk: flutter + + flutter_background_service_platform_interface: ^2.0.0 +dev_dependencies: + flutter_test: + sdk: flutter + +# For information on the generic Dart part of this file, see the +# following page: https://dart.dev/tools/pub/pubspec + +# The following section is specific to Flutter. +flutter: + # This section identifies this Flutter project as a plugin project. + # The 'pluginClass' and Android 'package' identifiers should not ordinarily + # be modified. They are used by the tooling to maintain consistency when + # adding or updating assets for this project. + plugin: + implements: flutter_background_service + platforms: + android: + package: id.flutter.flutter_background_service + pluginClass: FlutterBackgroundServicePlugin + dartPluginClass: FlutterBackgroundServiceAndroid + # To add assets to your plugin package, add an assets section, like this: + # assets: + # - images/a_dot_burr.jpeg + # - images/a_dot_ham.jpeg + # + # For details regarding assets in packages, see + # https://flutter.dev/assets-and-images/#from-packages + # + # An image asset can refer to one or more resolution-specific "variants", see + # https://flutter.dev/assets-and-images/#resolution-aware. + # To add custom fonts to your plugin package, add a fonts section here, + # in this "flutter" section. Each entry in this list should have a + # "family" key with the font family name, and a "fonts" key with a + # list giving the asset and other descriptors for the font. For + # example: + # fonts: + # - family: Schyler + # fonts: + # - asset: fonts/Schyler-Regular.ttf + # - asset: fonts/Schyler-Italic.ttf + # style: italic + # - family: Trajan Pro + # fonts: + # - asset: fonts/TrajanPro.ttf + # - asset: fonts/TrajanPro_Bold.ttf + # weight: 700 + # + # For details regarding fonts in packages, see + # https://flutter.dev/custom-fonts/#from-packages diff --git a/test/flutter_background_service_test.dart b/test/flutter_background_service_test.dart new file mode 100644 index 0000000..ab73b3a --- /dev/null +++ b/test/flutter_background_service_test.dart @@ -0,0 +1 @@ +void main() {}