Example usage for android.os SystemClock uptimeMillis

List of usage examples for android.os SystemClock uptimeMillis

Introduction

In this page you can find the example usage for android.os SystemClock uptimeMillis.

Prototype

@CriticalNative
native public static long uptimeMillis();

Source Link

Document

Returns milliseconds since boot, not counting time spent in deep sleep.

Usage

From source file:jp.morihirosoft.twwb.TwwbService.java

private void temporaryUnblockScreen() {
    if (DEBUG)
        Log.d(TAG, "temporaryUnblockScreen");
    unblockScreen();
    mStartTime = SystemClock.uptimeMillis();
}

From source file:com.github.shareme.gwsmaterialuikit.library.material.drawable.LineMorphingDrawable.java

private void resetAnimation() {
    mStartTime = SystemClock.uptimeMillis();
    mAnimProgress = 0f;
}

From source file:org.mariotaku.twidere.fragment.DirectMessagesFragment.java

@Override
public void onStart() {
    super.onStart();
    mTickerStopped = false;/* w w  w .j  a  v  a 2s.  com*/
    mHandler = new Handler();

    mTicker = new Runnable() {

        @Override
        public void run() {
            if (mTickerStopped)
                return;
            if (mListView != null && !mBusy) {
                mAdapter.notifyDataSetChanged();
            }
            final long now = SystemClock.uptimeMillis();
            final long next = now + TICKER_DURATION - now % TICKER_DURATION;
            mHandler.postAtTime(mTicker, next);
        }
    };
    mTicker.run();
    final IntentFilter filter = new IntentFilter();
    filter.addAction(BROADCAST_ACCOUNT_LIST_DATABASE_UPDATED);
    filter.addAction(BROADCAST_RECEIVED_DIRECT_MESSAGES_DATABASE_UPDATED);
    filter.addAction(BROADCAST_SENT_DIRECT_MESSAGES_DATABASE_UPDATED);
    filter.addAction(BROADCAST_RECEIVED_DIRECT_MESSAGES_REFRESHED);
    filter.addAction(BROADCAST_SENT_DIRECT_MESSAGES_REFRESHED);
    filter.addAction(BROADCAST_TASK_STATE_CHANGED);
    registerReceiver(mStatusReceiver, filter);
    if (mTwitterWrapper.isReceivedDirectMessagesRefreshing()
            || mTwitterWrapper.isSentDirectMessagesRefreshing()) {
        setRefreshing(false);
    } else {
        onRefreshComplete();
    }
}

From source file:io.selendroid.server.model.AndroidNativeElement.java

private void clickOnScreen(float x, float y) {
    SelendroidLogger.debug(String.format("Clicking at position [%f, %f]", x, y));
    final ServerInstrumentation inst = ServerInstrumentation.getInstance();
    long downTime = SystemClock.uptimeMillis();
    long eventTime = SystemClock.uptimeMillis();
    final MotionEvent event = MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_DOWN, x, y, 0);
    final MotionEvent event2 = MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_UP, x, y, 0);

    try {/* www  .j  av a2  s  . co  m*/
        inst.sendPointerSync(event);
        inst.sendPointerSync(event2);
        try {
            Thread.sleep(300);
        } catch (InterruptedException ignored) {
        }
    } catch (SecurityException e) {
        SelendroidLogger.error("error while clicking element", e);
    }
}

From source file:com.microsoft.office.integration.test.AbstractTest.java

public boolean waitForDialogToOpen(long timeout) {
    final long endTime = SystemClock.uptimeMillis() + timeout;

    if (isDialogOpen()) {
        return true;
    }//from  www. j  a va2  s . com

    while (SystemClock.uptimeMillis() < endTime) {

        if (isDialogOpen()) {
            return true;
        }
        try {
            Thread.sleep(SMALL_DELAY);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return false;
}

From source file:com.github.shareme.gwsmaterialuikit.library.material.drawable.LineMorphingDrawable.java

@Override
public void start() {
    resetAnimation();

    scheduleSelf(mUpdater, SystemClock.uptimeMillis() + ViewUtil.FRAME_DURATION);
    invalidateSelf();
}

From source file:com.example.rxretrofitdaggermvp.ui.adapters.ViewAnimatorAdapter.java

/**
 * Returns the delay in milliseconds after which animation for View with position mLastAnimatedPosition + 1 should start.
 *///from   w  w w. j  av a2s.  c  o  m
@SuppressLint("NewApi")
private int calculateAnimationDelay(final int position) {
    int delay;
    int firstVisiblePosition = 0, lastVisiblePosition = 0;
    if (mRecyclerView.getLayoutManager() instanceof LinearLayoutManager) {
        lastVisiblePosition = ((LinearLayoutManager) mRecyclerView.getLayoutManager())
                .findLastCompletelyVisibleItemPosition();
        firstVisiblePosition = ((LinearLayoutManager) mRecyclerView.getLayoutManager())
                .findFirstCompletelyVisibleItemPosition();
    } else if (mRecyclerView.getLayoutManager() instanceof LinearLayoutManager) {
        firstVisiblePosition = 0;
        lastVisiblePosition = mRecyclerView.getAdapter().getItemCount() - 1;
    }

    if (mLastAnimatedPosition > lastVisiblePosition)
        lastVisiblePosition = mLastAnimatedPosition;

    int numberOfItemsOnScreen = lastVisiblePosition - firstVisiblePosition;
    int numberOfAnimatedItems = position - 1 - mFirstAnimatedPosition;

    if (numberOfItemsOnScreen + 1 < numberOfAnimatedItems) {
        delay = mAnimationDelayMillis;

        if (mRecyclerView.getLayoutManager() instanceof GridLayoutManager) {
            int numColumns = ((GridLayoutManager) mRecyclerView.getLayoutManager()).getSpanCount();
            delay += mAnimationDelayMillis * (position % numColumns);
            Log.d("GAB", "Delay[" + position + "]=*" + lastVisiblePosition + "|" + firstVisiblePosition + "|");
        }
    } else {
        int delaySinceStart = (position - mFirstAnimatedPosition) * mAnimationDelayMillis;
        delay = Math.max(0, (int) (-SystemClock.uptimeMillis() + mAnimationStartMillis + mInitialDelayMillis
                + delaySinceStart));
    }
    Log.d("GAB",
            "Delay[" + position + "]=" + delay + "|" + lastVisiblePosition + "|" + firstVisiblePosition + "|");
    return delay;
}

From source file:com.googlecode.eyesfree.testing.BaseAccessibilityInstrumentationTestCase.java

private boolean assertAccessibilityStateSync(boolean enabled) {
    final boolean state;

    final long startTime = SystemClock.uptimeMillis();

    synchronized (mAccessibilityStateLock) {
        mManager.addAccessibilityStateChangeListener(mStateListener);

        try {// ww w .j  av a 2 s  .c  o  m
            while (true) {
                if (mManager.isEnabled() == enabled) {
                    break;
                }

                final long elapsed = (SystemClock.uptimeMillis() - startTime);
                final long timeLeft = (STATE_CHANGE_TIMEOUT - elapsed);
                if (timeLeft <= 0) {
                    break;
                }

                mAccessibilityStateLock.wait(timeLeft);
            }
        } catch (InterruptedException e) {
            // Do nothing.
        }

        state = mManager.isEnabled();

        assertEquals("Toggled accessibility state", enabled, state);

        mManager.removeAccessibilityStateChangeListener(mStateListener);
    }

    LogUtils.log(this, Log.VERBOSE, "Took %d ms to enable accessibility",
            (SystemClock.uptimeMillis() - startTime));

    return state;
}

From source file:org.kde.kdeconnect.Plugins.RemoteKeyboardPlugin.RemoteKeyboardPlugin.java

private boolean handleSpecialKey(int key, boolean shift, boolean ctrl, boolean alt) {
    int keyEvent = specialKeyMap.get(key, 0);
    if (keyEvent == 0)
        return false;
    InputConnection inputConn = RemoteKeyboardService.instance.getCurrentInputConnection();
    //        Log.d("RemoteKeyboardPlugin", "Handling special key " + key + " translated to " + keyEvent + " shift=" + shift + " ctrl=" + ctrl + " alt=" + alt);

    // special sequences:
    if (ctrl && (keyEvent == KeyEvent.KEYCODE_DPAD_RIGHT)) {
        // Ctrl + right -> next word
        ExtractedText extractedText = inputConn.getExtractedText(new ExtractedTextRequest(), 0);
        int pos = getCharPos(extractedText, ' ', keyEvent == KeyEvent.KEYCODE_DPAD_RIGHT);
        if (pos == -1)
            pos = currentTextLength(extractedText);
        else//from w w  w .  j  a v  a  2 s .c  o m
            pos++;
        int startPos = pos;
        int endPos = pos;
        if (shift) { // Shift -> select word (otherwise jump)
            Pair<Integer, Integer> sel = currentSelection(extractedText);
            int cursor = currentCursorPos(extractedText);
            //                Log.d("RemoteKeyboardPlugin", "Selection (to right): " + sel.first + " / " + sel.second + " cursor: " + cursor);
            startPos = cursor;
            if (sel.first < cursor || // active selection from left to right -> grow
                    sel.first > sel.second) // active selection from right to left -> shrink
                startPos = sel.first;
        }
        inputConn.setSelection(startPos, endPos);
    } else if (ctrl && keyEvent == KeyEvent.KEYCODE_DPAD_LEFT) {
        // Ctrl + left -> previous word
        ExtractedText extractedText = inputConn.getExtractedText(new ExtractedTextRequest(), 0);
        int pos = getCharPos(extractedText, ' ', keyEvent == KeyEvent.KEYCODE_DPAD_RIGHT);
        if (pos == -1)
            pos = 0;
        else
            pos++;
        int startPos = pos;
        int endPos = pos;
        if (shift) {
            Pair<Integer, Integer> sel = currentSelection(extractedText);
            int cursor = currentCursorPos(extractedText);
            //                Log.d("RemoteKeyboardPlugin", "Selection (to left): " + sel.first + " / " + sel.second + " cursor: " + cursor);
            startPos = cursor;
            if (cursor < sel.first || // active selection from right to left -> grow
                    sel.first < sel.second) // active selection from right to left -> shrink
                startPos = sel.first;
        }
        inputConn.setSelection(startPos, endPos);
    } else if (shift && (keyEvent == KeyEvent.KEYCODE_DPAD_LEFT || keyEvent == KeyEvent.KEYCODE_DPAD_RIGHT
            || keyEvent == KeyEvent.KEYCODE_DPAD_UP || keyEvent == KeyEvent.KEYCODE_DPAD_DOWN
            || keyEvent == KeyEvent.KEYCODE_MOVE_HOME || keyEvent == KeyEvent.KEYCODE_MOVE_END)) {
        // Shift + up/down/left/right/home/end
        long now = SystemClock.uptimeMillis();
        inputConn.sendKeyEvent(new KeyEvent(now, now, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_SHIFT_LEFT, 0, 0));
        inputConn.sendKeyEvent(
                new KeyEvent(now, now, KeyEvent.ACTION_DOWN, keyEvent, 0, KeyEvent.META_SHIFT_LEFT_ON));
        inputConn.sendKeyEvent(
                new KeyEvent(now, now, KeyEvent.ACTION_UP, keyEvent, 0, KeyEvent.META_SHIFT_LEFT_ON));
        inputConn.sendKeyEvent(new KeyEvent(now, now, KeyEvent.ACTION_UP, KeyEvent.KEYCODE_SHIFT_LEFT, 0, 0));
    } else if (keyEvent == KeyEvent.KEYCODE_NUMPAD_ENTER || keyEvent == KeyEvent.KEYCODE_ENTER) {
        // Enter key
        EditorInfo editorInfo = RemoteKeyboardService.instance.getCurrentInputEditorInfo();
        //            Log.d("RemoteKeyboardPlugin", "Enter: " + editorInfo.imeOptions);
        if (editorInfo != null
                && (((editorInfo.imeOptions & EditorInfo.IME_FLAG_NO_ENTER_ACTION) == 0) || ctrl)) { // Ctrl+Return overrides IME_FLAG_NO_ENTER_ACTION (FIXME: make configurable?)
            // check for special DONE/GO/etc actions first:
            int[] actions = { EditorInfo.IME_ACTION_GO, EditorInfo.IME_ACTION_NEXT, EditorInfo.IME_ACTION_SEND,
                    EditorInfo.IME_ACTION_SEARCH, EditorInfo.IME_ACTION_DONE }; // note: DONE should be last or we might hide the ime instead of "go"
            for (int i = 0; i < actions.length; i++) {
                if ((editorInfo.imeOptions & actions[i]) == actions[i]) {
                    //                        Log.d("RemoteKeyboardPlugin", "Enter-action: " + actions[i]);
                    inputConn.performEditorAction(actions[i]);
                    return true;
                }
            }
        } else {
            // else: fall back to regular Enter-event:
            //                Log.d("RemoteKeyboardPlugin", "Enter: normal keypress");
            inputConn.sendKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, keyEvent));
            inputConn.sendKeyEvent(new KeyEvent(KeyEvent.ACTION_UP, keyEvent));
        }
    } else {
        // default handling:
        inputConn.sendKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, keyEvent));
        inputConn.sendKeyEvent(new KeyEvent(KeyEvent.ACTION_UP, keyEvent));
    }

    return true;
}

From source file:org.mozilla.gecko.GeckoApp.java

String[] getPluginDirectories() {
    // we don't support Honeycomb
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB
            && Build.VERSION.SDK_INT < 14 /*Build.VERSION_CODES.ICE_CREAM_SANDWICH*/ )
        return new String[0];

    Log.w(LOGTAG, "zerdatime " + SystemClock.uptimeMillis() + " - start of getPluginDirectories");

    ArrayList<String> directories = new ArrayList<String>();
    PackageManager pm = mAppContext.getPackageManager();
    List<ResolveInfo> plugins = pm.queryIntentServices(new Intent(PLUGIN_ACTION),
            PackageManager.GET_SERVICES | PackageManager.GET_META_DATA);

    synchronized (mPackageInfoCache) {

        // clear the list of existing packageInfo objects
        mPackageInfoCache.clear();/*w  w  w .j a va2s .c o m*/

        for (ResolveInfo info : plugins) {

            // retrieve the plugin's service information
            ServiceInfo serviceInfo = info.serviceInfo;
            if (serviceInfo == null) {
                Log.w(LOGTAG, "Ignore bad plugin");
                continue;
            }

            // Blacklist HTC's flash lite.
            // See bug #704516 - We're not quite sure what Flash Lite does,
            // but loading it causes Flash to give errors and fail to draw.
            if (serviceInfo.packageName.equals("com.htc.flashliteplugin")) {
                Log.w(LOGTAG, "Skipping HTC's flash lite plugin");
                continue;
            }

            Log.w(LOGTAG, "Loading plugin: " + serviceInfo.packageName);

            // retrieve information from the plugin's manifest
            PackageInfo pkgInfo;
            try {
                pkgInfo = pm.getPackageInfo(serviceInfo.packageName,
                        PackageManager.GET_PERMISSIONS | PackageManager.GET_SIGNATURES);
            } catch (Exception e) {
                Log.w(LOGTAG, "Can't find plugin: " + serviceInfo.packageName);
                continue;
            }
            if (pkgInfo == null) {
                Log.w(LOGTAG,
                        "Loading plugin: " + serviceInfo.packageName + ". Could not load package information.");
                continue;
            }

            /*
             * find the location of the plugin's shared library. The default
             * is to assume the app is either a user installed app or an
             * updated system app. In both of these cases the library is
             * stored in the app's data directory.
             */
            String directory = pkgInfo.applicationInfo.dataDir + "/lib";
            final int appFlags = pkgInfo.applicationInfo.flags;
            final int updatedSystemFlags = ApplicationInfo.FLAG_SYSTEM
                    | ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
            // preloaded system app with no user updates
            if ((appFlags & updatedSystemFlags) == ApplicationInfo.FLAG_SYSTEM) {
                directory = PLUGIN_SYSTEM_LIB + pkgInfo.packageName;
            }

            // check if the plugin has the required permissions
            String permissions[] = pkgInfo.requestedPermissions;
            if (permissions == null) {
                Log.w(LOGTAG,
                        "Loading plugin: " + serviceInfo.packageName + ". Does not have required permission.");
                continue;
            }
            boolean permissionOk = false;
            for (String permit : permissions) {
                if (PLUGIN_PERMISSION.equals(permit)) {
                    permissionOk = true;
                    break;
                }
            }
            if (!permissionOk) {
                Log.w(LOGTAG, "Loading plugin: " + serviceInfo.packageName
                        + ". Does not have required permission (2).");
                continue;
            }

            // check to ensure the plugin is properly signed
            Signature signatures[] = pkgInfo.signatures;
            if (signatures == null) {
                Log.w(LOGTAG, "Loading plugin: " + serviceInfo.packageName + ". Not signed.");
                continue;
            }

            // determine the type of plugin from the manifest
            if (serviceInfo.metaData == null) {
                Log.e(LOGTAG, "The plugin '" + serviceInfo.name + "' has no type defined");
                continue;
            }

            String pluginType = serviceInfo.metaData.getString(PLUGIN_TYPE);
            if (!TYPE_NATIVE.equals(pluginType)) {
                Log.e(LOGTAG, "Unrecognized plugin type: " + pluginType);
                continue;
            }

            try {
                Class<?> cls = getPluginClass(serviceInfo.packageName, serviceInfo.name);

                //TODO implement any requirements of the plugin class here!
                boolean classFound = true;

                if (!classFound) {
                    Log.e(LOGTAG, "The plugin's class' " + serviceInfo.name
                            + "' does not extend the appropriate class.");
                    continue;
                }

            } catch (NameNotFoundException e) {
                Log.e(LOGTAG, "Can't find plugin: " + serviceInfo.packageName);
                continue;
            } catch (ClassNotFoundException e) {
                Log.e(LOGTAG, "Can't find plugin's class: " + serviceInfo.name);
                continue;
            }

            // if all checks have passed then make the plugin available
            mPackageInfoCache.add(pkgInfo);
            directories.add(directory);
        }
    }

    String[] result = directories.toArray(new String[directories.size()]);
    Log.w(LOGTAG, "zerdatime " + SystemClock.uptimeMillis() + " - end of getPluginDirectories");
    return result;
}