public c(Context paramContext, boolean paramBoolean) {
   i = paramContext;
   B = paramBoolean;
   j = ((NotificationManager) i.getSystemService("notification"));
   k = false;
   m = (g.addAndGet(1) + (int) SystemClock.elapsedRealtime());
   y.setTextSize(16.0F);
   if (Build.VERSION.SDK_INT >= 14) {
     paramContext = i;
     x =
         h.b(
             null,
             "android.app.Notification$Builder",
             new Class[] {Context.class},
             new Context[] {paramContext});
   }
   for (; ; ) {
     if (d != null) {}
     synchronized (c) {
       if (B) {
         c.add(Integer.valueOf(m));
         if (!f) {
           if (!bd.j()) {
             break label305;
           }
           paramContext =
               new Notification(
                   2130837892, FexApplication.a().getText(2131428105), System.currentTimeMillis());
           PendingIntent localPendingIntent =
               PendingIntent.getActivity(FexApplication.a(), 0, new Intent(), 0);
           paramContext.setLatestEventInfo(
               FexApplication.a(),
               FexApplication.a().getText(2131427488),
               FexApplication.a().getText(2131428105),
               localPendingIntent);
           flags |= 0x20;
           d.startForeground(g.addAndGet(1) + (int) SystemClock.elapsedRealtime(), paramContext);
           f = true;
         }
       }
       return;
       w = new af(i);
       continue;
       label305:
       paramContext = new Notification(0, null, System.currentTimeMillis());
     }
   }
 }
Esempio n. 2
0
 private void refreshMapInternal(DrawSettings drawSettings) {
   handler.removeMessages(MAP_REFRESH_MESSAGE);
   SurfaceHolder holder = getHolder();
   long ms = SystemClock.elapsedRealtime();
   synchronized (holder) {
     Canvas canvas = holder.lockCanvas();
     if (canvas != null) {
       try {
         final float ratioy = mapPosition == OsmandSettings.BOTTOM_CONSTANT ? 0.8f : 0.5f;
         final int cy = (int) (ratioy * getHeight());
         if (currentViewport.getPixWidth() != getWidth()
             || currentViewport.getPixHeight() != getHeight()
             || currentViewport.getCenterPixelY() != cy) {
           currentViewport.setPixelDimensions(getWidth(), getHeight(), 0.5f, ratioy);
           refreshBufferImage(drawSettings);
         }
         // make copy to avoid concurrency
         RotatedTileBox viewportToDraw = currentViewport.copy();
         fillCanvas(canvas, drawSettings);
         drawOverMap(canvas, viewportToDraw, drawSettings);
       } finally {
         holder.unlockCanvasAndPost(canvas);
       }
     }
     if (MEASURE_FPS) {
       main.calculateFPS(ms, SystemClock.elapsedRealtime());
     }
   }
 }
  @Override
  protected void onHandleIntent(Intent intent) {
    Bundle extras = intent.getExtras();
    GoogleCloudMessaging gcm = GoogleCloudMessaging.getInstance(this);

    String messageType = gcm.getMessageType(intent);

    if (!extras.isEmpty()) {
      if (GoogleCloudMessaging.MESSAGE_TYPE_SEND_ERROR.equals(messageType)) {
        sendNotification("Send error: " + extras.toString());
      } else if (GoogleCloudMessaging.MESSAGE_TYPE_DELETED.equals(messageType)) {
        sendNotification("Deleted messages on server: " + extras.toString());
      } else if (GoogleCloudMessaging.MESSAGE_TYPE_MESSAGE.equals(messageType)) {

        for (int i = 0; i < 3; i++) {
          Log.i(TAG, "Working... " + (i + 1) + "/5 @ " + SystemClock.elapsedRealtime());
          try {
            Thread.sleep(5000);
          } catch (InterruptedException e) {
          }
        }
        Log.i(TAG, "Completed work @ " + SystemClock.elapsedRealtime());

        sendNotification(
            "Message Received from Google GCM Server: " + extras.get(Config.MESSAGE_KEY));
        Log.i(TAG, "Received: " + extras.toString());
      }
    }
    GcmBroadcastReceiver.completeWakefulIntent(intent);
  }
 protected Long doInBackground(Object... objects) {
   Long startTime = SystemClock.elapsedRealtime();
   calculatePi();
   Long endTime = SystemClock.elapsedRealtime();
   accumulatedRunTime += (endTime - startTime);
   return (long) 0;
 }
Esempio n. 5
0
  // When the GPS status changes
  public void onGpsStatusChanged(int event) {
    switch (event) {
      case GpsStatus.GPS_EVENT_SATELLITE_STATUS:
        // If there's a previous location
        // and the time is outside of the timeout period
        if (!blockMessageShown
            && evade.locMan.lastLoc != null
            && SystemClock.elapsedRealtime() - evade.locMan.lastLocTime > TIMEOUT_DELAY) {
          // If the time is outside of the timeout period
          Toast.makeText(evade, "The aliens are blocking your transmissions.", Toast.LENGTH_SHORT)
              .show();
          evade.timer.cancel();
          blockMessageShown = true;
        }

        // If there's no previous location
        else if (evade.locMan.lastLoc == null) {
          // If we're within the acceptable wait range
          if (SystemClock.elapsedRealtime() - beginCheckTime < TIMEOUT_DELAY) {
            System.out.println("Waiting for a GPS fix");
          }
          // Otherwise, we need to timeout
          else {
            GPSTimeout();
            timeout = true;
          }
        }
        break;

      case GpsStatus.GPS_EVENT_FIRST_FIX:
        pro.hide();
        break;
    }
  }
  @SmallTest
  @Feature({"IntentHandling"})
  public void testNavigationWithForwardBack() {
    TabRedirectHandler handler = new TabRedirectHandler(mContext);
    handler.updateIntent(sYtIntent);
    assertFalse(handler.isOnNavigation());
    assertFalse(handler.shouldStayInChrome(false));
    assertFalse(handler.shouldStayInChrome(true));

    handler.updateNewUrlLoading(
        PageTransition.FORM_SUBMIT | PageTransition.FORWARD_BACK,
        false,
        true,
        SystemClock.elapsedRealtime(),
        0);
    assertTrue(handler.shouldStayInChrome(false));
    assertTrue(handler.shouldStayInChrome(true));
    handler.updateNewUrlLoading(
        PageTransition.LINK, false, false, SystemClock.elapsedRealtime(), 1);
    assertTrue(handler.shouldStayInChrome(false));
    assertTrue(handler.shouldStayInChrome(true));

    assertTrue(handler.isOnNavigation());
    assertEquals(0, handler.getLastCommittedEntryIndexBeforeStartingNavigation());

    SystemClock.sleep(1);
    handler.updateNewUrlLoading(PageTransition.LINK, false, true, SystemClock.elapsedRealtime(), 2);
    assertFalse(handler.shouldStayInChrome(false));
    assertFalse(handler.shouldStayInChrome(true));

    assertTrue(handler.isOnNavigation());
    assertEquals(2, handler.getLastCommittedEntryIndexBeforeStartingNavigation());
  }
  @Override
  protected Bitmap doInBackground(Void... params) {
    final long start = SystemClock.elapsedRealtime();

    Bitmap origin = mBitmapOriginal;
    Bitmap bitmap = BitmapUtils.doBlur(origin, 3, false);

    if (!running) {
      return null;
    }

    Canvas canvas = new Canvas(bitmap);
    canvas.drawColor(mForegroundColor);

    if (Build.DEBUG) {
      long delta = SystemClock.elapsedRealtime() - start;
      Log.d(
          TAG,
          "Dynamic background created in "
              + delta
              + " millis:"
              + " width="
              + bitmap.getWidth()
              + " height="
              + bitmap.getHeight());
    }

    return bitmap;
  }
 /** Execute a request without applying and rewrite rules. */
 public HttpResponse executeWithoutRewriting(HttpUriRequest request, HttpContext context)
     throws IOException {
   String code = "Error";
   long start = SystemClock.elapsedRealtime();
   try {
     HttpResponse response = mClient.execute(request, context);
     code = Integer.toString(response.getStatusLine().getStatusCode());
     return response;
   } catch (IOException e) {
     code = "IOException";
     throw e;
   } finally {
     // Record some statistics to the checkin service about the outcome.
     // Note that this is only describing execute(), not body download.
     try {
       long elapsed = SystemClock.elapsedRealtime() - start;
       ContentValues values = new ContentValues();
       values.put(
           Checkin.Stats.TAG, Checkin.Stats.Tag.HTTP_STATUS + ":" + mUserAgent + ":" + code);
       values.put(Checkin.Stats.COUNT, 1);
       values.put(Checkin.Stats.SUM, elapsed / 1000.0);
       mResolver.insert(Checkin.Stats.CONTENT_URI, values);
     } catch (Exception e) {
       Log.e(TAG, "Error recording stats", e);
     }
   }
 }
Esempio n. 9
0
  public void halt() { // modified
    long time = SystemClock.elapsedRealtime();

    int i = 0;
    for (RegisterAgent ra : ras) {
      unregister(i);
      while (ra != null
          && ra.CurrentState != RegisterAgent.UNREGISTERED
          && SystemClock.elapsedRealtime() - time < 2000)
        try {
          Thread.sleep(100);
        } catch (InterruptedException e1) {
        }
      if (wl[i].isHeld()) {
        wl[i].release();
        if (pwl[i] != null && pwl[i].isHeld()) pwl[i].release();
      }
      if (kas[i] != null) {
        Receiver.alarm(0, LoopAlarm.class);
        kas[i].halt();
      }
      Receiver.onText(Receiver.REGISTER_NOTIFICATION + i, null, 0, 0);
      if (ra != null) ra.halt();
      if (uas[i] != null) uas[i].hangup();
      if (sip_providers[i] != null) sip_providers[i].halt();
      i++;
    }
  }
Esempio n. 10
0
  @Override
  protected void onHandleIntent(Intent intent) {
    // TODO Auto-generated method stub
    Bundle extras = intent.getExtras();
    String msg = intent.getStringExtra("message");
    GoogleCloudMessaging gcm = GoogleCloudMessaging.getInstance(this);
    String messageType = gcm.getMessageType(intent);

    if (!extras.isEmpty()) {

      if (GoogleCloudMessaging.MESSAGE_TYPE_SEND_ERROR.equals(messageType)) {
        sendNotification("Send error: " + extras.toString());
      } else if (GoogleCloudMessaging.MESSAGE_TYPE_DELETED.equals(messageType)) {
        sendNotification("Deleted messages on server: " + extras.toString());
        // If it's a regular GCM message, do some work.
      } else if (GoogleCloudMessaging.MESSAGE_TYPE_MESSAGE.equals(messageType)) {
        // This loop represents the service doing some work.
        for (int i = 0; i < 5; i++) {
          Log.i(TAG, "Working... " + (i + 1) + "/5 @ " + SystemClock.elapsedRealtime());
          try {
            Thread.sleep(500);
          } catch (InterruptedException e) {
          }
        }
        Log.i(TAG, "Completed work @ " + SystemClock.elapsedRealtime());
        // Post notification of received message.
        // sendNotification("Received: " + extras.toString());
        sendNotification(msg);
        Log.i(TAG, "Received: " + extras.toString());
      }
    }
    GcmBroadcastReciever.completeWakefulIntent(intent);
  }
 private void m2619a(long j, JSONObject jSONObject) throws JSONException {
   int i = 1;
   boolean p = this.Cv.m1149p(j);
   int i2 = (!this.Cz.ev() || this.Cz.m1149p(j)) ? 0 : 1;
   if ((!this.CA.ev() || this.CA.m1149p(j)) && (!this.CB.ev() || this.CB.m1149p(j))) {
     i = 0;
   }
   i2 = i2 != 0 ? 2 : 0;
   if (i != 0) {
     i2 |= 1;
   }
   if (p || this.Cu == null) {
     this.Cu = new MediaStatus(jSONObject);
     this.Ct = SystemClock.elapsedRealtime();
     i2 = 7;
   } else {
     i2 = this.Cu.m108a(jSONObject, i2);
   }
   if ((i2 & 1) != 0) {
     this.Ct = SystemClock.elapsedRealtime();
     onStatusUpdated();
   }
   if ((i2 & 2) != 0) {
     this.Ct = SystemClock.elapsedRealtime();
     onStatusUpdated();
   }
   if ((i2 & 4) != 0) {
     onMetadataUpdated();
   }
   for (gr c : this.CF) {
     c.m1147c(j, 0);
   }
 }
 @Override
 public void onReceive(Context context, Intent intent) {
   String action = intent.getAction();
   if (TelephonyIntents.ACTION_NETWORK_SET_TIME.equals(action)) {
     mNitzTimeSetTime = SystemClock.elapsedRealtime();
   } else if (TelephonyIntents.ACTION_NETWORK_SET_TIMEZONE.equals(action)) {
     mNitzZoneSetTime = SystemClock.elapsedRealtime();
   }
 }
Esempio n. 13
0
 /** @return Vehicle flight time in seconds. */
 public long getFlightTime() {
   State droneState = getAttribute(AttributeType.STATE);
   if (droneState != null && droneState.isFlying()) {
     // calc delta time since last checked
     elapsedFlightTime += SystemClock.elapsedRealtime() - startTime;
     startTime = SystemClock.elapsedRealtime();
   }
   return elapsedFlightTime / 1000;
 }
  private void launchPlayer(long atTime) {
    Log.d("jdj-ExoPlayer", "Player LOADING at " + atTime);
    playerState = STATE_LOAD;

    if (mode != null && mode.equals("audio")) {
      audioShutter.setVisibility(View.VISIBLE);

      // seek to position to keep sync
      if (baganAtTime > 0 && atTime < SystemClock.elapsedRealtime()) {
        atTime = SystemClock.elapsedRealtime() + 1500; // already late so we postpone the start
        playerPosition = atTime - baganAtTime; // start at position shifted from baganAtTime
      }
    }

    if (player == null) {
      player = new ExPlayer(getRendererBuilder());
      player.addListener(this);
      player.seekTo(playerPosition);
      playerNeedsPrepare = true;
      if (exoLog) {
        eventLogger = new EventLogger();
        eventLogger.startSession();
        player.addListener(eventLogger);
        player.setInfoListener(eventLogger);
        player.setInternalErrorListener(eventLogger);
      }
    }
    if (playerNeedsPrepare) {
      player.prepare();
      playerNeedsPrepare = false;
    }
    player.setSurface(surfaceView.getHolder().getSurface());
    player.setPlayWhenReady(false);
    atTimeUse = atTime;

    // Sync with atTime
    new Handler()
        .postDelayed(
            new Runnable() {
              @Override
              public void run() {
                if (playerState == STATE_STOP) return;
                else if (playerState >= STATE_READY) {
                  Log.d("jdj-ExoPlayer", "Player PLAY - SYNC");
                  loadShutter.setVisibility(View.GONE);
                } else Log.d("jdj-ExoPlayer", "Player PLAY - OUT OF SYNC.. (not ready yet)");

                player.setPlayWhenReady(true);
                playerState = STATE_PLAY;
                Log.d(
                    "jdj-ExoPlayer",
                    " Timer shot shift: " + (SystemClock.elapsedRealtime() - atTimeUse));
              }
            },
            Math.max(0, atTime - SystemClock.elapsedRealtime()));
  }
Esempio n. 15
0
 private void drawStatistic(Canvas canvas) {
   renderCount++;
   long diffTime = SystemClock.elapsedRealtime() - lastTime;
   if (diffTime > 1000) {
     speed = Math.round(renderCount * 1000f / diffTime);
     lastTime = SystemClock.elapsedRealtime();
     renderCount = 0;
   }
   canvas.drawText("FPS: " + speed, 30, 100, paintStatistics);
 }
    @Override
    void updateLatLng(@NonNull Location location) {
      if (latLng == null) {
        // first location fix
        latLng = new LatLng(location);
        locationUpdateTimestamp = SystemClock.elapsedRealtime();
      }

      // updateLatLng timestamp
      long previousUpdateTimeStamp = locationUpdateTimestamp;
      locationUpdateTimestamp = SystemClock.elapsedRealtime();

      // calculate animation duration
      long locationUpdateDuration;
      if (previousUpdateTimeStamp == 0) {
        locationUpdateDuration = 0;
      } else {
        // TODO remove 10 * hack to multiply duration to workaround easing interpolation
        // (easeCamera)
        locationUpdateDuration = 10 * (locationUpdateTimestamp - previousUpdateTimeStamp);
      }

      // calculate interpolated location
      previousLocation = latLng;
      latLng = new LatLng(location);
      interpolatedLocation =
          new LatLng(
              (latLng.getLatitude() + previousLocation.getLatitude()) / 2,
              (latLng.getLongitude() + previousLocation.getLongitude()) / 2);

      // build new camera
      CameraPosition.Builder builder = new CameraPosition.Builder().target(interpolatedLocation);

      // add direction
      if (myBearingTrackingMode == MyBearingTracking.GPS) {
        if (location.hasBearing()) {
          builder.bearing(location.getBearing());
          gpsDirection = 0;
        }
      } else if (myBearingTrackingMode == MyBearingTracking.COMPASS) {
        if (!compassListener.isPaused()) {
          builder.bearing(compassListener.getCurrentDegree());
          compassDirection = 0;
        }
      }

      updateAccuracy(location);

      // animate to new camera
      mapboxMap.easeCamera(
          CameraUpdateFactory.newCameraPosition(builder.build()),
          (int) locationUpdateDuration,
          null);
    }
 private void hibernate() {
   // stop GPS until our next fix interval arrives
   stopNavigating();
   mFixCount = 0;
   mAlarmManager.cancel(mTimeoutIntent);
   mAlarmManager.cancel(mWakeupIntent);
   long now = SystemClock.elapsedRealtime();
   mAlarmManager.set(
       AlarmManager.ELAPSED_REALTIME_WAKEUP,
       SystemClock.elapsedRealtime() + mFixInterval * 1000,
       mWakeupIntent);
 }
 /**
  * Wait for a new frame, or until the specified timeout elapses. Returns true if a new frame was
  * received before the timeout.
  */
 public synchronized boolean waitForNewFrame(final long timeoutMs) throws InterruptedException {
   final long startTimeMs = SystemClock.elapsedRealtime();
   long timeRemainingMs = timeoutMs;
   while (!hasNewFrame && timeRemainingMs > 0) {
     wait(timeRemainingMs);
     final long elapsedTimeMs = SystemClock.elapsedRealtime() - startTimeMs;
     timeRemainingMs = timeoutMs - elapsedTimeMs;
   }
   final boolean didReceiveFrame = hasNewFrame;
   hasNewFrame = false;
   return didReceiveFrame;
 }
Esempio n. 19
0
  @Override
  public void onClick(View v) {
    boolean isPlaying = mMediaPlayer.isPlaying();
    if (v == mButtonPlayPause) {
      if (isPlaying) {
        mMediaPlayer.pause();
        mChronometer.stop();
        mButtonPlayPause.setImageResource(R.drawable.media_play);
        mButtonPlayPause.setContentDescription(getResources().getText(R.string.play));
      } else {
        mMediaPlayer.start();
        mChronometer.setBase(SystemClock.elapsedRealtime() - mMediaPlayer.getCurrentPosition());
        mChronometer.start();
        mButtonPlayPause.setImageResource(R.drawable.media_pause);
        mButtonPlayPause.setContentDescription(getResources().getText(R.string.pause));
      }
    } else if (v == mButtonSkip) {
      mIndex = (mIndex + 1) % mItems.size();
      onClick(mButtonStop);
      if (isPlaying) {
        onClick(mButtonPlayPause);
      }
    } else if (v == mButtonRewind) {
      // mMediaPlayer.seekTo(0);
      mChronometer.setBase(SystemClock.elapsedRealtime());

      if (mIndex == 0) {
        mIndex = mItems.size();
      }

      if (mIndex > 0) {
        mIndex = (mIndex - 1) % mItems.size();
      }

      onClick(mButtonStop);
      if (isPlaying) {
        onClick(mButtonPlayPause);
      }

    } else if (v == mButtonStop) {
      mMediaPlayer.stop();
      mMediaPlayer.reset();
      mChronometer.stop();
      mChronometer.setBase(SystemClock.elapsedRealtime());
      prepare();
    } else if (v == mButtonConfig) {

      Intent i = new Intent(this, ConfigActivity.class);
      startActivity(i);
      Toast.makeText(this, "Config", Toast.LENGTH_LONG).show();
    }
  }
Esempio n. 20
0
 @Override
 public void run() {
   try {
     MainActivity.this.showStatusTextFromThread("Connecting...\n");
     serverAddr = InetAddress.getByName("10.10.100.100");
     if (serverAddr == null) {
       MainActivity.this.showStatusTextFromThread("Can't create server address!\n");
       return;
     }
     socket = new Socket(serverAddr, 8899);
     if (!socket.isConnected()) {
       MainActivity.this.showStatusTextFromThread("Can't connect to Robot!\n");
       return;
     }
     MainActivity.this.showStatusTextFromThread("Connected to Robot.\n");
     PrintWriter out =
         new PrintWriter(
             new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);
     BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
     long lastWrite = SystemClock.elapsedRealtime();
     int count = 0;
     char ch = 'A';
     while (true) {
       long now = SystemClock.elapsedRealtime();
       if (now - lastWrite >= 3000) {
         if (count >= 5) break;
         MainActivity.this.showStatusTextFromThread(
             "(" + Long.toString(now) + ") SND: " + Character.toString(ch) + "\n");
         out.println(ch++);
         count++;
         lastWrite = now;
       }
       if (in.ready()) {
         char ch2 = (char) in.read();
         MainActivity.this.showStatusTextFromThread(
             "(" + Long.toString(now) + ") RCV: " + Character.toString(ch2) + "\n");
       } else {
         Thread.sleep(100);
       }
     }
   } catch (Exception e) {
     e.printStackTrace();
     MainActivity.this.showStatusTextFromThread(e.getLocalizedMessage());
   } finally {
     try {
       if (socket != null) socket.close();
     } catch (Exception e) {
       e.printStackTrace();
       MainActivity.this.showStatusTextFromThread(e.getLocalizedMessage());
     }
   }
 }
Esempio n. 21
0
 @SmallTest
 @Feature({"Android-AppBase"})
 public void testAddTimestampToIntent() {
   Intent intent = new Intent();
   assertEquals(-1, IntentHandler.getTimestampFromIntent(intent));
   // Check both before and after to make sure that the returned value is
   // really from {@link SystemClock#elapsedRealtime()}.
   long before = SystemClock.elapsedRealtime();
   IntentHandler.addTimestampToIntent(intent);
   long after = SystemClock.elapsedRealtime();
   assertTrue("Time should be increasing", before <= IntentHandler.getTimestampFromIntent(intent));
   assertTrue("Time should be increasing", IntentHandler.getTimestampFromIntent(intent) <= after);
 }
 @Override
 public boolean dispatchTouchEvent(MotionEvent ev) {
   // as long as the user is entering a pattern (i.e sending a touch
   // event that was handled by this screen), keep poking the
   // wake lock so that the screen will stay on.
   final boolean result = super.dispatchTouchEvent(ev);
   if (result
       && ((SystemClock.elapsedRealtime() - mLastPokeTime)
           > (UNLOCK_PATTERN_WAKE_INTERVAL_MS - 100))) {
     mLastPokeTime = SystemClock.elapsedRealtime();
   }
   return result;
 }
Esempio n. 23
0
  private static void storeIssue(FailureLevel level, String tag, String message) {
    if (Application.get() == null || !Application.isDebug() || !sEnabled) {
      return;
    }

    final LogEntry log = new LogEntry(System.currentTimeMillis(), level, tag, message);
    sHelper.insertLog(log);

    if (sLastCheck < (SystemClock.elapsedRealtime() - 5 * 1000)) {
      sLastCheck = SystemClock.elapsedRealtime();

      new SendTask(false).start();
    }
  }
 @Override
 protected Bitmap doInBackground(Integer... params) {
   try {
     publishProgress(getString(R.string.loading_image));
     long start = SystemClock.elapsedRealtime();
     InputStream in = getResources().openRawResource(params[0]);
     byte[] encoded = IOUtils.toByteArray(in);
     long time = SystemClock.elapsedRealtime() - start;
     publishProgress(getString(R.string.status, time, WebPBackport.isLibraryUsed()));
     return WebPBackport.decode(encoded);
   } catch (IOException e) {
     throw new RuntimeException(e);
   }
 }
Esempio n. 25
0
  /** Starts the ringtone and/or vibrator */
  void ring() {
    if (DBG) log("ring()...");

    synchronized (this) {
      try {
        mHardwareService.setAttentionLight(true);
      } catch (RemoteException ex) {
        // the other end of this binder call is in the system process.
      }

      if (shouldVibrate() && mVibratorThread == null) {
        mContinueVibrating = true;
        mVibratorThread = new VibratorThread();
        if (DBG) log("- starting vibrator...");
        mVibratorThread.start();
      }
      AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);

      if (audioManager.getStreamVolume(AudioManager.STREAM_RING) == 0) {
        if (DBG) log("skipping ring because volume is zero");
        return;
      }

      makeLooper();
      if (mFirstRingEventTime < 0) {
        mFirstRingEventTime = SystemClock.elapsedRealtime();
        mRingHandler.sendEmptyMessage(PLAY_RING_ONCE);
      } else {
        // For repeat rings, figure out by how much to delay
        // the ring so that it happens the correct amount of
        // time after the previous ring
        if (mFirstRingStartTime > 0) {
          // Delay subsequent rings by the delta between event
          // and play time of the first ring
          if (DBG) {
            log("delaying ring by " + (mFirstRingStartTime - mFirstRingEventTime));
          }
          mRingHandler.sendEmptyMessageDelayed(
              PLAY_RING_ONCE,
              mFirstRingStartTime
                  - mFirstRingEventTime); // Math.min(mRingtone.getDuration(), 2000));
        } else {
          // We've gotten two ring events so far, but the ring
          // still hasn't started. Reset the event time to the
          // time of this event to maintain correct spacing.
          mFirstRingEventTime = SystemClock.elapsedRealtime();
        }
      }
    }
  }
Esempio n. 26
0
  @Override
  public void onCreate() {
    super.onCreate();
    long startDate = SystemClock.elapsedRealtime();

    mContext = this;

    ProfilingUtils.start("App Startup");
    // Enable log recording
    AppLog.enableRecording(true);
    AppLog.i(T.UTILS, "WordPress.onCreate");

    if (!PackageUtils.isDebugBuild()) {
      Fabric.with(this, new Crashlytics());
    }

    versionName = PackageUtils.getVersionName(this);
    initWpDb();
    enableHttpResponseCache(mContext);

    // EventBus setup
    EventBus.TAG = "WordPress-EVENT";
    EventBus.builder()
        .logNoSubscriberMessages(false)
        .sendNoSubscriberEvent(false)
        .throwSubscriberException(true)
        .installDefaultEventBus();
    EventBus.getDefault().register(this);

    RestClientUtils.setUserAgent(getUserAgent());

    // Volley networking setup
    setupVolleyQueue();

    AppLockManager.getInstance().enableDefaultAppLockIfAvailable(this);
    if (AppLockManager.getInstance().isAppLockFeatureEnabled()) {
      AppLockManager.getInstance()
          .getCurrentAppLock()
          .setDisabledActivities(
              new String[] {"org.wordpress.android.ui.ShareIntentReceiverActivity"});
    }

    HelpshiftHelper.init(this);

    ApplicationLifecycleMonitor applicationLifecycleMonitor = new ApplicationLifecycleMonitor();
    registerComponentCallbacks(applicationLifecycleMonitor);
    registerActivityLifecycleCallbacks(applicationLifecycleMonitor);

    initAnalytics(SystemClock.elapsedRealtime() - startDate);
  }
    @Override
    void updateLatLng(@NonNull final Location location) {
      if (latLng == null) {
        // first location update
        latLng = new LatLng(location);
        locationUpdateTimestamp = SystemClock.elapsedRealtime();
      }

      // update LatLng location
      previousLocation = latLng;
      latLng = new LatLng(location);

      // update LatLng direction
      if (location.hasBearing()) {
        gpsDirection = clamp(location.getBearing() - (float) mapboxMap.getCameraPosition().bearing);
      }

      // update LatLng accuracy
      updateAccuracy(location);

      // calculate updateLatLng time + add some extra offset to improve animation
      long previousUpdateTimeStamp = locationUpdateTimestamp;
      locationUpdateTimestamp = SystemClock.elapsedRealtime();
      long locationUpdateDuration =
          (long) ((locationUpdateTimestamp - previousUpdateTimeStamp) * 1.2);

      // calculate interpolated entity
      interpolatedLocation =
          new LatLng(
              (latLng.getLatitude() + previousLocation.getLatitude()) / 2,
              (latLng.getLongitude() + previousLocation.getLongitude()) / 2);

      // animate changes
      if (locationChangeAnimator != null) {
        locationChangeAnimator.end();
        locationChangeAnimator = null;
      }

      locationChangeAnimator = ValueAnimator.ofFloat(0.0f, 1.0f);
      locationChangeAnimator.setDuration((long) (locationUpdateDuration * 1.2));
      locationChangeAnimator.addUpdateListener(
          new MarkerCoordinateAnimatorListener(this, previousLocation, interpolatedLocation));
      locationChangeAnimator.setInterpolator(new FastOutLinearInInterpolator());
      locationChangeAnimator.start();

      // use interpolated location as current location
      latLng = interpolatedLocation;
    }
Esempio n. 28
0
 @VisibleForTesting
 ConnectivityTask(Profile profile, int timeoutMs, ConnectivityResult callback) {
   mTimeoutMs = timeoutMs;
   mCallback = callback;
   mStartCheckTimeMs = SystemClock.elapsedRealtime();
   init(profile, timeoutMs);
 }
Esempio n. 29
0
  void finish(final String tag) {
    if (mRequestQueue != null) {
      mRequestQueue.finish(this);
    }
    if (MarkerLog.ENABLED) {
      final long threadId = Thread.currentThread().getId();
      if (Looper.myLooper() != Looper.getMainLooper()) {
        Handler mainThread = new Handler(Looper.getMainLooper());
        mainThread.post(
            new Runnable() {
              @Override
              public void run() {
                mEventLog.add(tag, threadId);
                mEventLog.finish(this.toString());
              }
            });
        return;
      }

      mEventLog.add(tag, threadId);
      mEventLog.finish(this.toString());
    } else {
      long requestTime = SystemClock.elapsedRealtime() - mRequestBirthTime;
      if (requestTime >= SLOW_REQUEST_THRESHOLD_MS) {
        VolleyLog.d("%d ms: %s", requestTime, this.toString());
      }
    }
  }
Esempio n. 30
0
 public void addMarker(String tag) {
   if (MarkerLog.ENABLED) {
     mEventLog.add(tag, Thread.currentThread().getId());
   } else if (mRequestBirthTime == 0) {
     mRequestBirthTime = SystemClock.elapsedRealtime();
   }
 }