我正在开发一个计步器应用程序，我计算步行的步数，并在午夜将其更新到服务器。我有一个连续运行的服务来做这一切。
这是我的服务：
public class StepCounterService extends Service implements SensorEventListener, StepListener, WebServiceInterface, GoogleApiClient.ConnectionCallbacks,
GoogleApiClient.OnConnectionFailedListener, LocationListener {
private static final int SERVICE_ID = 27;
private static final int SEND_SESSION_REQUEST_CODE = 1;
private static final int SEND_ACTIVITY_REQUEST_CODE = 2;
private static final int MAIN_NOTIFICATION_ID = 3;
private static final int SECONDARY_NOTIFICATION_ID = 4;
private LocalBroadcastManager broadcaster;
static final public String STEP_INCREMENT = "com.app.STEP_INCREMENTED";
static final public String SESSION_COMPLETE = "com.app.SESSION_COMPLETE";
static final public String ACTIVITY_COMPLETE = "com.app.ACTIVITY_COMPLETE";
static final public String STEP_INCREMENT_KEY = "step_count";
Session session;
private StepDetector stepDetector;
private SensorManager sensorManager;
private Sensor sensor;
private int numberOfSteps = 0;
private GoogleApiClient googleApiClient;
private LocationRequest mLocationRequest;
double currentLatitude;
double currentLongitude;
ArrayList<String> arrayListLocations;
private AlarmManager sendActivityAlarmManager;
private PendingIntent activityAlarmIntent;
private NotificationManager notificationManager;
RemoteViews contentView;
PowerManager.WakeLock wl;
private String TAG = "Wake Lock Tag";
private int SET_LAST_LOCATION_REQUEST_CODE = 5;
@Nullable
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
// TODO Auto-generated method stub
return START_STICKY;
}
@Override
public void onTaskRemoved(Intent rootIntent) {
// TODO Auto-generated method stub
System.out.println("---- In onTaskRemoved Function");
restartKilledService();
}
@Override
public void onDestroy() {
System.out.println("---- In onDestroy Function");
if (wl != null) {
wl.release();
}
super.onDestroy();
restartKilledService();
}
void restartKilledService() {
System.out.println("---- In restartKilledService Function");
Intent restartService = new Intent(getApplicationContext(), StepCounterService.class);
restartService.setPackage(getPackageName());
PendingIntent restartServicePI = PendingIntent.getService(getApplicationContext(), StepCounterService.SERVICE_ID, restartService, PendingIntent.FLAG_CANCEL_CURRENT);
AlarmManager alarmService = (AlarmManager) getApplicationContext().getSystemService(Context.ALARM_SERVICE);
alarmService.set(AlarmManager.RTC_WAKEUP, SystemClock.elapsedRealtime() + 100, restartServicePI);
}
@Override
public void onCreate() {
// TODO Auto-generated method stub
PowerManager pm = (PowerManager) getApplicationContext().getSystemService(getApplicationContext().POWER_SERVICE);
wl = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
wl.acquire();
super.onCreate();
session = new Session(this);
buildGoogleApiClient();
broadcaster = LocalBroadcastManager.getInstance(this);
sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
stepDetector = new StepDetector();
stepDetector.registerListener(StepCounterService.this);
Context ctx = getApplicationContext();
Calendar cal = Calendar.getInstance();
AlarmManager am = (AlarmManager) ctx.getSystemService(Context.ALARM_SERVICE);
long interval = 1000 * 60 * 5; // 5 minutes in milliseconds
Intent serviceIntent = new Intent(ctx, StepCounterService.class);
PendingIntent servicePendingIntent = PendingIntent.getService(ctx, StepCounterService.SERVICE_ID, serviceIntent, PendingIntent.FLAG_CANCEL_CURRENT);
am.setRepeating(AlarmManager.RTC_WAKEUP, cal.getTimeInMillis(), interval, servicePendingIntent);
sensorManager.registerListener(this, sensor, SensorManager.SENSOR_DELAY_FASTEST);
notificationManager = (NotificationManager) getSystemService(Activity.NOTIFICATION_SERVICE);
contentView = new RemoteViews(getPackageName(), R.layout.notification_layout);
contentView.setImageViewResource(R.id.image, R.drawable.notif_icon);
if (session.getUser() != null && !(session.getUser().getName().equals("")))
updateMainNotification(session.getTodaySteps() + "");
startAlarm();
}
protected synchronized void buildGoogleApiClient() {
googleApiClient = new GoogleApiClient.Builder(this)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.addApi(LocationServices.API)
.build();
googleApiClient.connect();
mLocationRequest = LocationRequest.create()
.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
.setInterval(10 * 1000) // 10 seconds, in milliseconds
.setFastestInterval(1 * 1000);
}
@Override
public void onSensorChanged(SensorEvent event) {
if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
stepDetector.updateAccel(event.timestamp, event.values[0], event.values[1], event.values[2]);
}
}
@Override
public void step(long timeNs) {
numberOfSteps = session.getTodaySteps();
numberOfSteps++;
sendStepIncrementBroadcast(numberOfSteps);
session.setTodaySteps(numberOfSteps);
if (session.getUser() != null && !(session.getUser().getName().equals("")))
updateMainNotification(numberOfSteps + "");
else {
try {
notificationManager.cancel(MAIN_NOTIFICATION_ID);
} catch (Exception e) {
}
}
}
public void sendStepIncrementBroadcast(int numberOfSteps) {
Intent intent = new Intent(STEP_INCREMENT);
intent.putExtra(STEP_INCREMENT_KEY, numberOfSteps);
broadcaster.sendBroadcast(intent);
}
@Override
public void onAccuracyChanged(Sensor sensor, int i) {
}
public float[] getDataFromSteps(int stepsCount) {
float caloriesCount = 0;
float creditsCount = 0;
try {
double adjustedWeight = Double.parseDouble(session.getUser().getWeight()) / LinksAndKeys.weightAdjuster;
caloriesCount = Math.round(((adjustedWeight * LinksAndKeys.metValue) / LinksAndKeys.setPace) * (stepsCount / LinksAndKeys.stepsPerMile));
caloriesCount = caloriesCount * 1.2f;
creditsCount = caloriesCount / 25.4f;
} catch (Exception e) {
caloriesCount = 0;
creditsCount = 0;
}
float[] resultantFloat = {caloriesCount, creditsCount};
return resultantFloat;
}
private void startAlarm() {
sendActivityAlarmManager = (AlarmManager) this.getSystemService(Context.ALARM_SERVICE);
Intent intent = new Intent(this, ActivityCompleteReceiver.class);
activityAlarmIntent = PendingIntent.getBroadcast(this, 0, intent, 0);
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(System.currentTimeMillis());
calendar.set(Calendar.HOUR_OF_DAY, 23);
calendar.set(Calendar.MINUTE, 58);
// calendar.set(Calendar.HOUR_OF_DAY, generateRandomTime()[0]);
// calendar.set(Calendar.MINUTE, generateRandomTime()[1]);
if (System.currentTimeMillis() > calendar.getTimeInMillis()) {
calendar.add(Calendar.DAY_OF_YEAR, 1);
}
sendActivityAlarmManager.setRepeating(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(),
AlarmManager.INTERVAL_DAY, activityAlarmIntent);
}
private void updateMainNotification(String stepsValue) {
String title = "Today: " + stepsValue + " steps - " + LinksAndKeys.decimalFormat.format(getDataFromSteps(session.getTodaySteps())[1]) + " FIMOs";
String message = "Keep Walking and Keep Earning";
contentView.setTextViewText(R.id.textViewTitle, title);
contentView.setTextViewText(R.id.textViewMessage, message);
Intent notificationIntent = new Intent(StepCounterService.this, SplashActivity.class);
notificationIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
PendingIntent intent = PendingIntent.getActivity(StepCounterService.this, 0, notificationIntent, 0);
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this)
.setSmallIcon(R.drawable.running_icon)
.setContent(contentView).setContentIntent(intent);
Notification notification = mBuilder.build();
notification.flags |= Notification.FLAG_ONGOING_EVENT;
// notificationManager.notify(MAIN_NOTIFICATION_ID, notification);
startForeground(MAIN_NOTIFICATION_ID, notification);
}
private void updateReminderNotification() {
String title = "A gentle reminder";
String message = "Its time to get on track";
contentView.setTextViewText(R.id.textViewTitle, title);
contentView.setTextViewText(R.id.textViewMessage, message);
Intent notificationIntent = new Intent(StepCounterService.this, SplashActivity.class);
notificationIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
PendingIntent intent = PendingIntent.getActivity(StepCounterService.this, 0, notificationIntent, 0);
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this)
.setSmallIcon(R.drawable.running_icon)
.setContent(contentView).setContentIntent(intent);
Notification notification = mBuilder.build();
notificationManager.notify(SECONDARY_NOTIFICATION_ID, notification);
}
private int[] generateRandomTime() {
int[] timeIntegers = new int[2];
final Random r = new Random();
timeIntegers[0] = r.nextInt(58 - 56) + 56;
timeIntegers[1] = r.nextInt(59 - 1) + 1;
return timeIntegers;
}
}
以下是活动完成接收器：
public class ActivityCompleteReceiver extends BroadcastReceiver implements WebServiceInterface {
Session session;
private LocalBroadcastManager broadcaster;
static final public String ACTIVITY_COMPLETE = "com.fimo.ACTIVITY_COMPLETE";
private static final int SEND_ACTIVITY_REQUEST_CODE = 1;
Gson gson;
MyDatabase myDatabase;
UserActivity currentUserActivity;
@Override
public void onReceive(Context context, Intent intent) {
session = new Session(context);
broadcaster = LocalBroadcastManager.getInstance(context);
myDatabase = new MyDatabase(context);
gson = new Gson();
sendActivityToServer(context, session.getUser().getId(), session.getTodaySteps());
}
private void sendActivityToServer(Context context, String id, int steps) {
Calendar c = Calendar.getInstance();
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
String date = dateFormat.format(c.getTime());
UserActivity userActivity = new UserActivity();
userActivity.setDate(date);
userActivity.setSteps(steps);
userActivity.setCalories(getDataFromSteps(steps)[0]);
userActivity.setCredits(getDataFromSteps(steps)[1]);
currentUserActivity = userActivity;
if (isNetworkAvailable(context)) {
HashMap<String, String> paramsList = new HashMap<>();
ArrayList<UserActivity> arrayListUserActivity = myDatabase.getAllUserActivities();
arrayListUserActivity.add(userActivity);
paramsList.put(LinksAndKeys.ID_KEY, id);
paramsList.put(LinksAndKeys.DATA_KEY, gson.toJson(arrayListUserActivity));
Log.d("Receiver Request ----", id + " - " + gson.toJson(arrayListUserActivity));
WebServiceController webServiceController = new WebServiceController(
context, ActivityCompleteReceiver.this);
String hitURL = LinksAndKeys.SEND_ACTIVITY_URL;
webServiceController.sendSilentRequest(false, hitURL, paramsList, SEND_ACTIVITY_REQUEST_CODE);
} else {
myDatabase.addUserActivity(currentUserActivity);
currentUserActivity = null;
Intent in = new Intent(ACTIVITY_COMPLETE);
broadcaster.sendBroadcast(in);
session.setTodaySteps(0);
}
}
private boolean isNetworkAvailable(Context context) {
ConnectivityManager connectivityManager
= (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
return activeNetworkInfo != null && activeNetworkInfo.isConnected();
}
@Override
public void getResponse(int responseCode, String responseString, String requestType, int requestCode) {
if (requestCode == SEND_ACTIVITY_REQUEST_CODE && responseCode == 200) {
try {
JSONObject responseObject = new JSONObject(responseString);
String message = responseObject.getString("message");
if (message.equals("Success")) {
myDatabase.deleteAllUserActivities();
JSONObject jsonObject = responseObject.getJSONObject("data");
session.setServerCredits(Float.parseFloat(jsonObject.getString("credits")));
Intent in = new Intent(ACTIVITY_COMPLETE);
broadcaster.sendBroadcast(in);
session.setTodaySteps(0);
} else {
myDatabase.addUserActivity(currentUserActivity);
currentUserActivity = null;
Intent in = new Intent(ACTIVITY_COMPLETE);
broadcaster.sendBroadcast(in);
session.setTodaySteps(0);
}
} catch (Exception e) {
myDatabase.addUserActivity(currentUserActivity);
currentUserActivity = null;
Intent in = new Intent(ACTIVITY_COMPLETE);
broadcaster.sendBroadcast(in);
session.setTodaySteps(0);
}
} else {
if (currentUserActivity != null) {
myDatabase.addUserActivity(currentUserActivity);
currentUserActivity = null;
Intent in = new Intent(ACTIVITY_COMPLETE);
broadcaster.sendBroadcast(in);
session.setTodaySteps(0);
}
}
}
public float[] getDataFromSteps(int stepsCount) {
float caloriesCount = 0;
float creditsCount = 0;
try {
double adjustedWeight = Double.parseDouble(session.getUser().getWeight()) / LinksAndKeys.weightAdjuster;
caloriesCount = Math.round(((adjustedWeight * LinksAndKeys.metValue) / LinksAndKeys.setPace) * (stepsCount / LinksAndKeys.stepsPerMile));
caloriesCount = caloriesCount * 1.2f;
creditsCount = caloriesCount / 25.4f;
} catch (Exception e) {
caloriesCount = 0;
creditsCount = 0;
}
float[] resultantFloat = {caloriesCount, creditsCount};
return resultantFloat;
}
}
编写的代码应该以这种方式运行：
每天计算用户所采取的步数。 - ＆GT;在11.56-11.59之间的特定时间的午夜，将数据发送到活动完成接收器 - ＆gt;如果互联网可用，接收器接收数据并尝试将其发送到服务器。如果没有，则将其保存到本地数据库 - ＆gt;保存或发送后，将步骤重置为0，服务从第0天开始再次计数。
问题是服务实际上在给定时间内没有工作，并且接收者没有收到活动完整意图。如果我打开手机并通过设置一个距当前时间几分钟的时间进行测试，则服务正常。但是如果电话长时间不受影响，我认为这种情况会在服务停止工作时发生。这是我的猜测，实际问题可能是其他问题。任何建议或解决方案都受到高度赞赏。
答案 0 :(得分：2)
从API级别19开始，使用AlarmManager.setRepeating()来调用您的ActivityCompleteReceiver，并不可靠。 Android可以根据需要延迟发送此警报。如果您确实希望每天在确切时间触发此操作，则应执行以下操作：
使用AlarmManager.setExact()并为下一个触发时间设置一个警报（不是重复警报）。发出此警报后，发送您的统计信息或任何您想要的信息，然后拨打AlarmManager.setExact()设置下一个警报（第二天）。您应该避免使用setRepeating()，除非您绝对需要使用它。
您需要观察使用唤醒锁的操作，因为您当前的代码始终保持部分唤醒锁定，这将阻止设备进入睡眠状态，从而耗尽电池电量。阅读有关如何优化电池使用的信息。
答案 1 :(得分：2)
您似乎遇到了Android 6.0中引入的Doze模式限制，并在Android 7.0中拆分为Light和Deep Doze：
当设备使用电池电源并且屏幕已关闭一段时间后，设备会进入Doze并应用第一个限制子集：它会关闭应用程序网络访问，并延迟作业和同步。如果设备在进入Doze后静止一段时间，系统会将其余的Doze限制应用于PowerManager.WakeLock，AlarmManager警报，GPS和Wi-Fi扫描。无论是否应用了部分或全部Doze限制，系统都会唤醒设备以进行简短的维护窗口，在此期间允许应用程序访问网络并执行任何延迟作业/同步。
所以即使你设法发出警报，例如使用setAndAllowWhileIdle()，您仍然无法访问网络。通常的建议是使用JobScheduler或类似的东西，例如Firebase JobDispatcher和Evernote Android-Job。这些框架允许配置在网络可用时运行的作业，例如，与JobInfo.Builder.setRequiredNetworkType()。当Doze进入“闲置维护”窗口时，时间将受到摆布，但至少你知道在发生这种情况时你会有网络访问。
如果需要更多时间控制，则可以设置在空闲时唤醒的警报，然后使用GCM / FCM高优先级消息强制进行网络访问。我不确定你是如何选择Firebase端的那些 - 这取决于你的服务器端代码。
答案 2 :(得分：0)
•已启动的服务可以使用startForeground（int，Notification）API将服务置于前台状态，系统认为该服务是用户主动了解的内容，因此在低级别时不会成为查杀的候选者记忆。 （从理论上讲，服务在当前前台应用程序的极端内存压力下被杀死仍然是可能的，但实际上这不应该是一个问题。
1：使用startForeground开始使用服务通知。
2：从OnCommandStart返回START_STICKY。
private void showLocationNotification()
{
Notification notification = new Notification.Builder(this)
.setContentTitle("Service")
.setContentText("Service Started Successfully")
.setSmallIcon(R.mipmap.ic_launcher)
.build();
startForeground(1, notification);
}
On Create Above Above方法
3.您的服务标记中的清单文件将此android:stopWithTask="false"
答案 3 :(得分：0)
我认为您的主要问题是Android不是一个旨在持续运行的系统。
即使使用服务甚至使用startForeground，也无法保证您的进程在任何时候都不会被系统杀死。
Android不是服务器的操作系统。服务在最初几个小时内被杀的可能性很低，但在2或3天后变得非常高
Android的一个主要优先事项是节省电池而不是保持一些服务运行。
另外，根据您的设计，很明显您的应用程序在电池耗尽应用程序中得分非常高，因为您打算不允许设备进入深度睡眠状态，并且用户必须每天为电池充电一次以上
我认为你应该改变你的设计，并将你的运行时间限制在有限的时间段，如典型的体育应用程序。
答案 4 :(得分：0)
将您的服务设为Foreground service并显示持续通知。它几乎永远不会被杀死。所有可靠的计步器应用程序都出于持续通知，原因完全相同。音乐播放器也是这样做的。
答案 5 :(得分：0)
从Android 6.0打瞌睡模式开始，通过在设备长时间不使用时延迟应用程序的后台CPU和网络活动来减少电池消耗。
要确认打盹模式是服务未运行的原因，请使用下面的命令强行将手机置于打盹模式，并检查服务是否运行（将时间设置为几分钟后）
$ adb shell dumpsys deviceidle force-idle
我们还可以通过打盹模式中的白名单来测试。在设置＆gt;中手动配置白名单电池＆gt;电池优化并选择您的应用程序。 https://developer.android.com/training/monitoring-device-state/doze-standby.html