Jobscheduler

transport/transport-runtime/src/main/java/com/google/android/datatransport/runtime/TransportRuntime.java

@@ -19,6 +19,7 @@
 import android.support.annotation.VisibleForTesting;
 import com.google.android.datatransport.TransportFactory;
 import com.google.android.datatransport.runtime.scheduling.Scheduler;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.Uploader;
 import com.google.android.datatransport.runtime.synchronization.SynchronizationGuard;
 import com.google.android.datatransport.runtime.time.Clock;
 import com.google.android.datatransport.runtime.time.Monotonic;
@@ -43,19 +44,22 @@ public class TransportRuntime implements TransportInternal {
   private final Clock uptimeClock;
   private final Scheduler scheduler;
   private final SynchronizationGuard guard;
+  private final Uploader uploader;
 
   @Inject
   TransportRuntime(
       BackendRegistry backendRegistry,
       @WallTime Clock eventClock,
       @Monotonic Clock uptimeClock,
       Scheduler scheduler,
-      SynchronizationGuard guard) {
+      SynchronizationGuard guard,
+      Uploader uploader) {
     this.backendRegistry = backendRegistry;
     this.eventClock = eventClock;
     this.uptimeClock = uptimeClock;
     this.scheduler = scheduler;
     this.guard = guard;
+    this.uploader = uploader;
   }
 
   /**
@@ -98,6 +102,11 @@ public TransportFactory newFactory(String backendName) {
     return new TransportFactoryImpl(backendName, this);
   }
 
+  @RestrictTo(RestrictTo.Scope.LIBRARY)
+  public Uploader getUploader() {
+    return uploader;
+  }
+
   @Override
   public void send(SendRequest request) {
     scheduler.schedule(request.getBackendName(), convert(request));

transport/transport-runtime/src/main/java/com/google/android/datatransport/runtime/TransportRuntimeModule.java

@@ -14,8 +14,13 @@
 
 package com.google.android.datatransport.runtime;
 
-import com.google.android.datatransport.runtime.scheduling.ImmediateScheduler;
+import android.content.Context;
+import android.os.Build;
+import com.google.android.datatransport.runtime.scheduling.DefaultScheduler;
 import com.google.android.datatransport.runtime.scheduling.Scheduler;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.AlarmManagerScheduler;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.JobInfoScheduler;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.WorkScheduler;
 import com.google.android.datatransport.runtime.scheduling.persistence.EventStore;
 import com.google.android.datatransport.runtime.scheduling.persistence.SQLiteEventStore;
 import com.google.android.datatransport.runtime.synchronization.SynchronizationGuard;
@@ -50,8 +55,23 @@ static Clock uptimeClock() {
   }
 
   @Provides
-  static Scheduler scheduler(Executor executor, BackendRegistry registry) {
-    return new ImmediateScheduler(executor, registry);
+  static WorkScheduler workScheduler(
+      Context context, EventStore eventStore, @WallTime Clock eventClock) {
+    if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+      return new JobInfoScheduler(context, eventStore, eventClock);
+    } else {
+      return new AlarmManagerScheduler(context, eventStore, eventClock);
+    }
+  }
+
+  @Provides
+  static Scheduler scheduler(
+      Executor executor,
+      BackendRegistry registry,
+      WorkScheduler workScheduler,
+      EventStore eventStore,
+      SynchronizationGuard guard) {
+    return new DefaultScheduler(executor, registry, workScheduler, eventStore, guard);
   }
 
   @Binds

transport/transport-runtime/src/main/java/com/google/android/datatransport/runtime/scheduling/DefaultScheduler.java

@@ -14,15 +14,61 @@
 
 package com.google.android.datatransport.runtime.scheduling;
 
+import com.google.android.datatransport.runtime.BackendRegistry;
 import com.google.android.datatransport.runtime.EventInternal;
+import com.google.android.datatransport.runtime.TransportBackend;
+import com.google.android.datatransport.runtime.TransportRuntime;
+import com.google.android.datatransport.runtime.scheduling.jobscheduling.WorkScheduler;
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStore;
+import com.google.android.datatransport.runtime.synchronization.SynchronizationGuard;
+import java.util.concurrent.Executor;
+import java.util.logging.Logger;
+import javax.inject.Inject;
 
 /**
  * Placeholder for the eventual scheduler that will support persistence, retries, respect network
  * conditions and QoS.
  */
 public class DefaultScheduler implements Scheduler {
+
+  private static final Logger LOGGER = Logger.getLogger(TransportRuntime.class.getName());
+  private final WorkScheduler workScheduler;
+  private final Executor executor;
+  private final BackendRegistry backendRegistry;
+  private final EventStore eventStore;
+  private final SynchronizationGuard guard;
+
+  @Inject
+  public DefaultScheduler(
+      Executor executor,
+      BackendRegistry backendRegistry,
+      WorkScheduler workScheduler,
+      EventStore eventStore,
+      SynchronizationGuard guard) {
+    this.executor = executor;
+    this.backendRegistry = backendRegistry;
+    this.workScheduler = workScheduler;
+    this.eventStore = eventStore;
+    this.guard = guard;
+  }
+
   @Override
   public void schedule(String backendName, EventInternal event) {
-    // TODO: implement.
+    executor.execute(
+        () -> {
+          TransportBackend transportBackend = backendRegistry.get(backendName);
+          if (transportBackend == null) {
+            LOGGER.warning(String.format("Logger backend '%s' is not registered", backendName));
+            return;
+          }
+          EventInternal decoratedEvent = transportBackend.decorate(event);
+          guard.runCriticalSection(
+              10000,
+              () -> {
+                eventStore.persist(backendName, decoratedEvent);
+                workScheduler.schedule(backendName, 0);
+                return null;
+              });
+        });
   }
 }

transport/transport-runtime/src/main/java/com/google/android/datatransport/runtime/scheduling/jobscheduling/AlarmManagerScheduler.java

@@ -0,0 +1,39 @@
+// Copyright 2018 Google LLC
+//
+// 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 com.google.android.datatransport.runtime.scheduling.jobscheduling;
+
+import android.content.Context;
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStore;
+import com.google.android.datatransport.runtime.time.Clock;
+import javax.inject.Inject;
+
+public class AlarmManagerScheduler implements WorkScheduler {
+
+  private final Context context;
+
+  private final EventStore eventStore;
+
+  private final Clock clock;
+
+  @Inject
+  public AlarmManagerScheduler(Context applicationContext, EventStore eventStore, Clock clock) {
+    this.context = applicationContext;
+    this.eventStore = eventStore;
+    this.clock = clock;
+  }
+
+  @Override
+  public void schedule(String backendName, int attemptNumber) {}
+}

transport/transport-runtime/src/main/java/com/google/android/datatransport/runtime/scheduling/jobscheduling/JobInfoScheduler.java

@@ -0,0 +1,84 @@
+// Copyright 2018 Google LLC
+//
+// 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 com.google.android.datatransport.runtime.scheduling.jobscheduling;
+
+import android.annotation.TargetApi;
+import android.app.job.JobInfo;
+import android.app.job.JobScheduler;
+import android.content.ComponentName;
+import android.content.Context;
+import android.os.Build;
+import android.os.PersistableBundle;
+import android.support.annotation.RequiresApi;
+import com.google.android.datatransport.runtime.scheduling.persistence.EventStore;
+import com.google.android.datatransport.runtime.time.Clock;
+import java.util.zip.Adler32;
+import javax.inject.Inject;
+
+public class JobInfoScheduler implements WorkScheduler {
+
+  private final Context context;
+
+  private final EventStore eventStore;
+
+  private final Clock clock;
+
+  @Inject
+  public JobInfoScheduler(Context applicationContext, EventStore eventStore, Clock clock) {
+    this.context = applicationContext;
+    this.eventStore = eventStore;
+    this.clock = clock;
+  }
+
+  private int getJobId(String backendName) {
+    Adler32 checksum = new Adler32();
+    checksum.update(backendName.getBytes());
+    return (int) checksum.getValue();
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+  private boolean isJobServiceOn(JobScheduler scheduler, int jobId) {
+    for (JobInfo jobInfo : scheduler.getAllPendingJobs()) {
+      if (jobInfo.getId() == jobId) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @TargetApi(Build.VERSION_CODES.M)
+  @android.support.annotation.RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+  @Override
+  public void schedule(String backendName, int attemptNumber) {
+    ComponentName serviceComponent = new ComponentName(context, JobInfoSchedulerService.class);
+    JobScheduler jobScheduler = context.getSystemService(JobScheduler.class);
+    int jobId = getJobId(backendName);
+    // Check if there exists a job scheduled for this backend name.
+    if (isJobServiceOn(jobScheduler, jobId)) return;
+    // Obtain the next available call time for the backend.
+    long timeDiff = eventStore.getNextCallTime(backendName) - clock.getTime();
+    // Schedule the build.
+    PersistableBundle bundle = new PersistableBundle();
+    bundle.putInt(SchedulerUtil.ATTEMPT_NUMBER, attemptNumber);
+    bundle.putString(SchedulerUtil.BACKEND_NAME, backendName);
+    JobInfo.Builder builder = new JobInfo.Builder(jobId, serviceComponent);
+    builder.setMinimumLatency(
+        clock.getTime()
+            + SchedulerUtil.getScheduleDelay(timeDiff, 5000, attemptNumber)); // wait at least
+    builder.setExtras(bundle);
+    builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY);
+    jobScheduler.schedule(builder.build());
+  }
+}

transport/transport-runtime/src/main/java/com/google/android/datatransport/runtime/scheduling/jobscheduling/JobInfoSchedulerService.java

@@ -0,0 +1,41 @@
+// Copyright 2018 Google LLC
+//
+// 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 com.google.android.datatransport.runtime.scheduling.jobscheduling;
+
+import android.app.job.JobParameters;
+import android.app.job.JobService;
+import android.os.Build;
+import com.google.android.datatransport.runtime.TransportRuntime;
+
+/** JobService to be scheduled by the JobScheduler. start another service */
+@android.support.annotation.RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+public class JobInfoSchedulerService extends JobService {
+
+  @Override
+  public boolean onStartJob(JobParameters params) {
+    String backendName = params.getExtras().getString(SchedulerUtil.BACKEND_NAME);
+    int attemptNumber = params.getExtras().getInt(SchedulerUtil.ATTEMPT_NUMBER);
+    TransportRuntime.initialize(getApplicationContext());
+    TransportRuntime.getInstance()
+        .getUploader()
+        .upload(backendName, attemptNumber, () -> this.jobFinished(params, false));
+    return true;
+  }
+
+  @Override
+  public boolean onStopJob(JobParameters params) {
+    return false;
+  }
+}

transport/transport-runtime/src/main/java/com/google/android/datatransport/runtime/scheduling/jobscheduling/SchedulerUtil.java

@@ -0,0 +1,31 @@
+// Copyright 2018 Google LLC
+//
+// 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 com.google.android.datatransport.runtime.scheduling.jobscheduling;
+
+public class SchedulerUtil {
+
+  static final String ATTEMPT_NUMBER = "attemptNumber";
+
+  static final String BACKEND_NAME = "backendName";
+
+  static final String APPLICATION_BUNDLE_ID = "appBundleId";
+
+  static long getScheduleDelay(long backendTimeDiff, int delta, int numberOfAttempts) {
+    if (numberOfAttempts > 3) {
+      return 1000000000;
+    }
+    return Math.max((long) (Math.pow(delta / 1000, numberOfAttempts)) * 1000, backendTimeDiff);
+  }
+}

transport/transport-runtime/src/main/java/com/google/android/datatransport/runtime/scheduling/jobscheduling/Uploader.java

@@ -0,0 +1,25 @@
+// Copyright 2018 Google LLC
+//
+// 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 com.google.android.datatransport.runtime.scheduling.jobscheduling;
+
+import javax.inject.Inject;
+
+public class Uploader {
+
+  @Inject
+  public Uploader() {}
+
+  void upload(String backendName, int attemptNumber, Runnable callback) {}
+}

transport/transport-runtime/src/main/java/com/google/android/datatransport/runtime/scheduling/jobscheduling/WorkScheduler.java

@@ -0,0 +1,19 @@
+// Copyright 2018 Google LLC
+//
+// 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 com.google.android.datatransport.runtime.scheduling.jobscheduling;
+
+public interface WorkScheduler {
+  void schedule(String backendName, int numberOfAttempts);
+}