Example usage for java.nio ByteOrder BIG_ENDIAN

List of usage examples for java.nio ByteOrder BIG_ENDIAN

Introduction

In this page you can find the example usage for java.nio ByteOrder BIG_ENDIAN.

Prototype

ByteOrder BIG_ENDIAN

To view the source code for java.nio ByteOrder BIG_ENDIAN.

Click Source Link

Document

This constant represents big endian.

Usage

From source file:io.warp10.continuum.gts.GTSHelper.java

public static final long labelsId_slow(byte[] key, Map<String, String> labels) {
    ///*from  w w w. java 2 s . c o  m*/
    // Allocate an array to hold both name and value hashes
    //

    long[] hashes = new long[labels.size() * 2];

    //
    // Compute hash for each name and each value
    //

    int idx = 0;

    long[] sipkey = SipHashInline.getKey(key);

    for (Entry<String, String> entry : labels.entrySet()) {
        hashes[idx] = SipHashInline.hash24_palindromic(sipkey[0], sipkey[1],
                entry.getKey().getBytes(Charsets.UTF_8));
        hashes[idx + 1] = SipHashInline.hash24_palindromic(sipkey[0], sipkey[1],
                entry.getValue().getBytes(Charsets.UTF_8));
        idx += 2;
    }

    //
    // Sort array by label hash then value hash.
    // Given the normally reduced number of labels, we can use a simple bubble sort...
    //

    for (int i = 0; i < labels.size() - 1; i++) {
        for (int j = i + 1; j < labels.size(); j++) {
            if (hashes[i * 2] > hashes[j * 2]) {
                //
                // We need to swap name and value ids at i and j
                //
                long tmp = hashes[j * 2];
                hashes[j * 2] = hashes[i * 2];
                hashes[i * 2] = tmp;
                tmp = hashes[j * 2 + 1];
                hashes[j * 2 + 1] = hashes[i * 2 + 1];
                hashes[i * 2 + 1] = tmp;
            } else if (hashes[i * 2] == hashes[j * 2] && hashes[i * 2 + 1] > hashes[j * 2 + 1]) {
                //
                // We need to swap value ids at i and j
                //
                long tmp = hashes[j * 2 + 1];
                hashes[j * 2 + 1] = hashes[i * 2 + 1];
                hashes[i * 2 + 1] = tmp;
            }
        }
    }

    //
    // Now compute the SipHash of all the longs in the order we just determined
    // 

    byte[] buf = new byte[hashes.length * 8];
    ByteBuffer bb = ByteBuffer.wrap(buf);
    bb.order(ByteOrder.BIG_ENDIAN);

    for (long hash : hashes) {
        bb.putLong(hash);
    }

    //return SipHashInline.hash24(sipkey[0], sipkey[1], buf, 0, buf.length);
    return SipHashInline.hash24_palindromic(sipkey[0], sipkey[1], buf, 0, buf.length);
}

From source file:nodomain.freeyourgadget.gadgetbridge.service.devices.pebble.PebbleProtocol.java

@Override
public GBDeviceEvent[] decodeResponse(byte[] responseData) {
    ByteBuffer buf = ByteBuffer.wrap(responseData);
    buf.order(ByteOrder.BIG_ENDIAN);
    short length = buf.getShort();
    short endpoint = buf.getShort();
    GBDeviceEvent devEvts[] = null;//from   w w  w. j  a  v a2  s  . c o  m
    byte pebbleCmd;
    switch (endpoint) {
    case ENDPOINT_MUSICCONTROL:
        pebbleCmd = buf.get();
        GBDeviceEventMusicControl musicCmd = new GBDeviceEventMusicControl();
        switch (pebbleCmd) {
        case MUSICCONTROL_NEXT:
            musicCmd.event = GBDeviceEventMusicControl.Event.NEXT;
            break;
        case MUSICCONTROL_PREVIOUS:
            musicCmd.event = GBDeviceEventMusicControl.Event.PREVIOUS;
            break;
        case MUSICCONTROL_PLAY:
            musicCmd.event = GBDeviceEventMusicControl.Event.PLAY;
            break;
        case MUSICCONTROL_PAUSE:
            musicCmd.event = GBDeviceEventMusicControl.Event.PAUSE;
            break;
        case MUSICCONTROL_PLAYPAUSE:
            musicCmd.event = GBDeviceEventMusicControl.Event.PLAYPAUSE;
            break;
        case MUSICCONTROL_VOLUMEUP:
            musicCmd.event = GBDeviceEventMusicControl.Event.VOLUMEUP;
            break;
        case MUSICCONTROL_VOLUMEDOWN:
            musicCmd.event = GBDeviceEventMusicControl.Event.VOLUMEDOWN;
            break;
        default:
            break;
        }
        devEvts = new GBDeviceEvent[] { musicCmd };
        break;
    case ENDPOINT_PHONECONTROL:
        pebbleCmd = buf.get();
        GBDeviceEventCallControl callCmd = new GBDeviceEventCallControl();
        switch (pebbleCmd) {
        case PHONECONTROL_HANGUP:
            callCmd.event = GBDeviceEventCallControl.Event.END;
            break;
        default:
            LOG.info("Unknown PHONECONTROL event" + pebbleCmd);
            break;
        }
        devEvts = new GBDeviceEvent[] { callCmd };
        break;
    case ENDPOINT_FIRMWAREVERSION:
        pebbleCmd = buf.get();
        GBDeviceEventVersionInfo versionCmd = new GBDeviceEventVersionInfo();

        buf.getInt(); // skip
        versionCmd.fwVersion = getFixedString(buf, 32);

        mFwMajor = versionCmd.fwVersion.charAt(1) - 48;
        LOG.info("Pebble firmware major detected as " + mFwMajor);

        byte[] tmp = new byte[9];
        buf.get(tmp, 0, 9);
        int hwRev = buf.get() + 8;
        if (hwRev >= 0 && hwRev < hwRevisions.length) {
            versionCmd.hwVersion = hwRevisions[hwRev];
        }
        devEvts = new GBDeviceEvent[] { versionCmd };
        break;
    case ENDPOINT_APPMANAGER:
        pebbleCmd = buf.get();
        switch (pebbleCmd) {
        case APPMANAGER_GETAPPBANKSTATUS:
            GBDeviceEventAppInfo appInfoCmd = new GBDeviceEventAppInfo();
            int slotCount = buf.getInt();
            int slotsUsed = buf.getInt();
            appInfoCmd.apps = new GBDeviceApp[slotsUsed];
            boolean[] slotInUse = new boolean[slotCount];

            for (int i = 0; i < slotsUsed; i++) {
                int id = buf.getInt();
                int index = buf.getInt();
                slotInUse[index] = true;
                String appName = getFixedString(buf, 32);
                String appCreator = getFixedString(buf, 32);

                int flags = buf.getInt();

                GBDeviceApp.Type appType;
                if ((flags & 16) == 16) { // FIXME: verify this assumption
                    appType = GBDeviceApp.Type.APP_ACTIVITYTRACKER;
                } else if ((flags & 1) == 1) { // FIXME: verify this assumption
                    appType = GBDeviceApp.Type.WATCHFACE;
                } else {
                    appType = GBDeviceApp.Type.APP_GENERIC;
                }
                Short appVersion = buf.getShort();
                appInfoCmd.apps[i] = new GBDeviceApp(tmpUUIDS.get(i), appName, appCreator,
                        appVersion.toString(), appType);
            }
            for (int i = 0; i < slotCount; i++) {
                if (!slotInUse[i]) {
                    appInfoCmd.freeSlot = (byte) i;
                    LOG.info("found free slot " + i);
                    break;
                }
            }
            devEvts = new GBDeviceEvent[] { appInfoCmd };
            break;
        case APPMANAGER_GETUUIDS:
            GBDeviceEventSendBytes sendBytes = new GBDeviceEventSendBytes();
            sendBytes.encodedBytes = encodeSimpleMessage(ENDPOINT_APPMANAGER, APPMANAGER_GETAPPBANKSTATUS);
            devEvts = new GBDeviceEvent[] { sendBytes };
            tmpUUIDS.clear();
            slotsUsed = buf.getInt();
            for (int i = 0; i < slotsUsed; i++) {
                UUID uuid = getUUID(buf);
                LOG.info("found uuid: " + uuid);
                tmpUUIDS.add(uuid);
            }
            break;
        case APPMANAGER_REMOVEAPP:
            GBDeviceEventAppManagement deleteRes = new GBDeviceEventAppManagement();
            deleteRes.type = GBDeviceEventAppManagement.EventType.DELETE;

            int result = buf.getInt();
            switch (result) {
            case APPMANAGER_RES_SUCCESS:
                deleteRes.event = GBDeviceEventAppManagement.Event.SUCCESS;
                break;
            default:
                deleteRes.event = GBDeviceEventAppManagement.Event.FAILURE;
                break;
            }
            devEvts = new GBDeviceEvent[] { deleteRes };
            break;
        default:
            LOG.info("Unknown APPMANAGER event" + pebbleCmd);
            break;
        }
        break;
    case ENDPOINT_PUTBYTES:
        pebbleCmd = buf.get();
        GBDeviceEventAppManagement installRes = new GBDeviceEventAppManagement();
        installRes.type = GBDeviceEventAppManagement.EventType.INSTALL;
        switch (pebbleCmd) {
        case PUTBYTES_INIT:
            installRes.token = buf.getInt();
            installRes.event = GBDeviceEventAppManagement.Event.SUCCESS;
            break;
        default:
            installRes.token = buf.getInt();
            installRes.event = GBDeviceEventAppManagement.Event.FAILURE;
            break;
        }
        devEvts = new GBDeviceEvent[] { installRes };
        break;
    case ENDPOINT_APPLICATIONMESSAGE:
    case ENDPOINT_LAUNCHER:
        pebbleCmd = buf.get();
        last_id = buf.get();
        UUID uuid = getUUID(buf);

        switch (pebbleCmd) {
        case APPLICATIONMESSAGE_PUSH:
            LOG.info((endpoint == ENDPOINT_LAUNCHER ? "got LAUNCHER PUSH from UUID : "
                    : "got APPLICATIONMESSAGE PUSH from UUID : ") + uuid);
            AppMessageHandler handler = mAppMessageHandlers.get(uuid);
            if (handler != null) {
                if (handler.isEnabled()) {
                    if (endpoint == ENDPOINT_APPLICATIONMESSAGE) {
                        ArrayList<Pair<Integer, Object>> dict = decodeDict(buf);
                        devEvts = handler.handleMessage(dict);
                    } else {
                        currentRunningApp = uuid;
                        devEvts = handler.onAppStart();
                    }
                } else {
                    devEvts = new GBDeviceEvent[] { null };
                }
            } else {
                try {
                    if (endpoint == ENDPOINT_APPLICATIONMESSAGE) {
                        devEvts = decodeDictToJSONAppMessage(uuid, buf);
                    } else {
                        currentRunningApp = uuid;
                        GBDeviceEventAppManagement gbDeviceEventAppManagement = new GBDeviceEventAppManagement();
                        gbDeviceEventAppManagement.uuid = uuid;
                        gbDeviceEventAppManagement.type = GBDeviceEventAppManagement.EventType.START;
                        gbDeviceEventAppManagement.event = GBDeviceEventAppManagement.Event.SUCCESS;
                        devEvts = new GBDeviceEvent[] { gbDeviceEventAppManagement };
                    }
                } catch (JSONException e) {
                    LOG.error(e.getMessage());
                    return null;
                }
            }
            break;
        case APPLICATIONMESSAGE_ACK:
            LOG.info("got APPLICATIONMESSAGE/LAUNCHER (EP " + endpoint + ")  ACK");
            devEvts = new GBDeviceEvent[] { null };
            break;
        case APPLICATIONMESSAGE_NACK:
            LOG.info("got APPLICATIONMESSAGE/LAUNCHER (EP " + endpoint + ")  NACK");
            devEvts = new GBDeviceEvent[] { null };
            break;
        case APPLICATIONMESSAGE_REQUEST:
            LOG.info("got APPLICATIONMESSAGE/LAUNCHER (EP " + endpoint + ")  REQUEST");
            devEvts = new GBDeviceEvent[] { null };
            break;
        default:
            break;
        }
        break;
    case ENDPOINT_PHONEVERSION:
        pebbleCmd = buf.get();
        switch (pebbleCmd) {
        case PHONEVERSION_REQUEST:
            LOG.info("Pebble asked for Phone/App Version - repLYING!");
            GBDeviceEventSendBytes sendBytes = new GBDeviceEventSendBytes();
            sendBytes.encodedBytes = encodePhoneVersion(PHONEVERSION_REMOTE_OS_ANDROID);
            devEvts = new GBDeviceEvent[] { sendBytes };
            break;
        default:
            break;
        }
        break;
    case ENDPOINT_DATALOG:
        devEvts = decodeDatalog(buf, length);
        break;
    case ENDPOINT_SCREENSHOT:
        devEvts = new GBDeviceEvent[] { decodeScreenshot(buf, length) };
        break;
    case ENDPOINT_EXTENSIBLENOTIFS:
    case ENDPOINT_NOTIFICATIONACTION:
        devEvts = decodeAction(buf);
        break;
    case ENDPOINT_PING:
        devEvts = new GBDeviceEvent[] { decodePing(buf) };
        break;
    case ENDPOINT_APPFETCH:
        devEvts = new GBDeviceEvent[] { decodeAppFetch(buf) };
        break;
    case ENDPOINT_SYSTEMMESSAGE:
        devEvts = new GBDeviceEvent[] { decodeSystemMessage(buf) };
        break;
    case ENDPOINT_APPRUNSTATE:
        devEvts = decodeAppRunState(buf);
        break;
    case ENDPOINT_BLOBDB:
        devEvts = new GBDeviceEvent[] { decodeBlobDb(buf) };
        break;
    case ENDPOINT_APPREORDER:
        devEvts = new GBDeviceEvent[] { decodeAppReorder(buf) };
        break;
    case ENDPOINT_APPLOGS:
        decodeAppLogs(buf);
        break;
    //            case ENDPOINT_VOICECONTROL:
    //                devEvts = new GBDeviceEvent[]{decodeVoiceControl(buf)};
    //            case ENDPOINT_AUDIOSTREAM:
    //                LOG.debug(GB.hexdump(responseData, 0, responseData.length));
    //                break;
    default:
        break;
    }

    return devEvts;
}

From source file:nodomain.freeyourgadget.gadgetbridge.service.devices.pebble.PebbleProtocol.java

private UUID getUUID(ByteBuffer buf) {
    ByteOrder byteOrder = buf.order();
    buf.order(ByteOrder.BIG_ENDIAN);
    long uuid_high = buf.getLong();
    long uuid_low = buf.getLong();
    buf.order(byteOrder);// ww  w  .j  a  v a  2  s .  c o m
    return new UUID(uuid_high, uuid_low);
}