Copy BitwiseInputStream into cellbroadcastservice
Bug: 135956699
Test: manual and unit tests
Change-Id: Ifcd73ef5c87bcee52f0ddaee77cad03832cee316
Merged-In: Ifcd73ef5c87bcee52f0ddaee77cad03832cee316
diff --git a/src/com/android/cellbroadcastservice/BearerData.java b/src/com/android/cellbroadcastservice/BearerData.java
index b1324d7..6ebd041 100644
--- a/src/com/android/cellbroadcastservice/BearerData.java
+++ b/src/com/android/cellbroadcastservice/BearerData.java
@@ -21,8 +21,6 @@
import android.telephony.cdma.CdmaSmsCbProgramData;
import android.util.Log;
-import com.android.internal.util.BitwiseInputStream;
-
/**
* An object to decode CDMA SMS bearer data.
*/
diff --git a/src/com/android/cellbroadcastservice/BitwiseInputStream.java b/src/com/android/cellbroadcastservice/BitwiseInputStream.java
new file mode 100644
index 0000000..eb4ed38
--- /dev/null
+++ b/src/com/android/cellbroadcastservice/BitwiseInputStream.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * 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.android.cellbroadcastservice;
+
+/**
+ * An object that provides bitwise incremental read access to a byte array.
+ *
+ * This is useful, for example, when accessing a series of fields that
+ * may not be aligned on byte boundaries.
+ *
+ * NOTE -- This class is not threadsafe.
+ */
+public class BitwiseInputStream {
+
+ // The byte array being read from.
+ private byte[] mBuf;
+
+ // The current position offset, in bits, from the msb in byte 0.
+ private int mPos;
+
+ // The last valid bit offset.
+ private int mEnd;
+
+ /**
+ * An exception to report access problems.
+ */
+ public static class AccessException extends Exception {
+ public AccessException(String s) {
+ super("BitwiseInputStream access failed: " + s);
+ }
+ }
+
+ /**
+ * Create object from byte array.
+ *
+ * @param buf a byte array containing data
+ */
+ public BitwiseInputStream(byte[] buf) {
+ mBuf = buf;
+ mEnd = buf.length << 3;
+ mPos = 0;
+ }
+
+ /**
+ * Return the number of bit still available for reading.
+ */
+ public int available() {
+ return mEnd - mPos;
+ }
+
+ /**
+ * Read some data and increment the current position.
+ *
+ * The 8-bit limit on access to bitwise streams is intentional to
+ * avoid endianness issues.
+ *
+ * @param bits the amount of data to read (gte 0, lte 8)
+ * @return byte of read data (possibly partially filled, from lsb)
+ */
+ public int read(int bits) throws AccessException {
+ int index = mPos >>> 3;
+ int offset = 16 - (mPos & 0x07) - bits; // &7==%8
+ if ((bits < 0) || (bits > 8) || ((mPos + bits) > mEnd)) {
+ throw new AccessException(
+ "illegal read (pos " + mPos + ", end " + mEnd + ", bits " + bits + ")");
+ }
+ int data = (mBuf[index] & 0xFF) << 8;
+ if (offset < 8) data |= mBuf[index + 1] & 0xFF;
+ data >>>= offset;
+ data &= (-1 >>> (32 - bits));
+ mPos += bits;
+ return data;
+ }
+
+ /**
+ * Read data in bulk into a byte array and increment the current position.
+ *
+ * @param bits the amount of data to read
+ * @return newly allocated byte array of read data
+ */
+ public byte[] readByteArray(int bits) throws AccessException {
+ int bytes = (bits >>> 3) + ((bits & 0x07) > 0 ? 1 : 0); // &7==%8
+ byte[] arr = new byte[bytes];
+ for (int i = 0; i < bytes; i++) {
+ int increment = Math.min(8, bits - (i << 3));
+ arr[i] = (byte) (read(increment) << (8 - increment));
+ }
+ return arr;
+ }
+
+ /**
+ * Increment the current position and ignore contained data.
+ *
+ * @param bits the amount by which to increment the position
+ */
+ public void skip(int bits) throws AccessException {
+ if ((mPos + bits) > mEnd) {
+ throw new AccessException(
+ "illegal skip (pos " + mPos + ", end " + mEnd + ", bits " + bits + ")");
+ }
+ mPos += bits;
+ }
+}