alpha of the {@link Paint} for drawing separators
+ * spinnerwheel.
+ * @param alpha alpha value from 0 to 255
+ */
+ @SuppressWarnings("unused") // Called via reflection
+ public void setSeparatorsPaintAlpha(int alpha) {
+ mSeparatorsPaint.setAlpha(alpha);
+ invalidate();
+ }
+
+ /**
+ * Sets the coeff of the {@link Paint} for drawing
+ * the selector spinnerwheel.
+ *
+ * @param coeff Coefficient from 0 (selector is passive) to 1 (selector is active)
+ */
+ abstract public void setSelectorPaintCoeff(float coeff);
+
+
+ //--------------------------------------------------------------------------
+ //
+ // Processing scroller events
+ //
+ //--------------------------------------------------------------------------
+
+ @Override
+ protected void onScrollTouched() {
+ mDimSelectorWheelAnimator.cancel();
+ mDimSeparatorsAnimator.cancel();
+ setSelectorPaintCoeff(1);
+ setSeparatorsPaintAlpha(mSelectionDividerActiveAlpha);
+ }
+
+ @Override
+ protected void onScrollTouchedUp() {
+ super.onScrollTouchedUp();
+ fadeSelectorWheel(750);
+ lightSeparators(750);
+ }
+
+ @Override
+ protected void onScrollFinished() {
+ fadeSelectorWheel(500);
+ lightSeparators(500);
+ }
+
+ //----------------------------------
+ // Animating components
+ //----------------------------------
+
+ /**
+ * Fade the selector spinnerwheel via an animation.
+ *
+ * @param animationDuration The duration of the animation.
+ */
+ private void fadeSelectorWheel(long animationDuration) {
+ mDimSelectorWheelAnimator.setDuration(animationDuration);
+ mDimSelectorWheelAnimator.start();
+ }
+
+ /**
+ * Fade the selector spinnerwheel via an animation.
+ *
+ * @param animationDuration The duration of the animation.
+ */
+ private void lightSeparators(long animationDuration) {
+ mDimSeparatorsAnimator.setDuration(animationDuration);
+ mDimSeparatorsAnimator.start();
+ }
+
+
+ //--------------------------------------------------------------------------
+ //
+ // Layout measuring
+ //
+ //--------------------------------------------------------------------------
+
+ /**
+ * Perform layout measurements
+ */
+ abstract protected void measureLayout();
+
+
+ //--------------------------------------------------------------------------
+ //
+ // Drawing stuff
+ //
+ //--------------------------------------------------------------------------
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ super.onDraw(canvas);
+
+ if (mViewAdapter != null && mViewAdapter.getItemsCount() > 0) {
+ if (rebuildItems()) {
+ measureLayout();
+ }
+ doItemsLayout();
+ drawItems(canvas);
+ }
+ }
+
+ /**
+ * Draws items on specified canvas
+ *
+ * @param canvas the canvas for drawing
+ */
+ abstract protected void drawItems(Canvas canvas);
+}
diff --git b/src/antistatic/spinnerwheel/ItemsRange.java a/src/antistatic/spinnerwheel/ItemsRange.java
new file mode 100644
index 0000000..2d48a1e
--- /dev/null
+++ a/src/antistatic/spinnerwheel/ItemsRange.java
@@ -0,0 +1,86 @@
+/*
+ * android-spinnerwheel
+ * https://github.com/ai212983/android-spinnerwheel
+ *
+ * based on
+ *
+ * Android Wheel Control.
+ * https://code.google.com/p/android-wheel/
+ *
+ * Copyright 2011 Yuri Kanivets
+ *
+ * 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 antistatic.spinnerwheel;
+
+ /**
+ * Range for visible items.
+ */
+ public class ItemsRange {
+ // First item number
+ private int first;
+
+ // Items count
+ private int count;
+
+ /**
+ * Default constructor. Creates an empty range
+ */
+ public ItemsRange() {
+ this(0, 0);
+ }
+
+ /**
+ * Constructor
+ * @param first the number of first item
+ * @param count the count of items
+ */
+ public ItemsRange(int first, int count) {
+ this.first = first;
+ this.count = count;
+ }
+
+ /**
+ * Gets number of first item
+ * @return the number of the first item
+ */
+ public int getFirst() {
+ return first;
+ }
+
+ /**
+ * Gets number of last item
+ * @return the number of last item
+ */
+ public int getLast() {
+ return getFirst() + getCount() - 1;
+ }
+
+ /**
+ * Get items count
+ * @return the count of items
+ */
+ public int getCount() {
+ return count;
+ }
+
+ /**
+ * Tests whether item is contained by range
+ * @param index the item number
+ * @return true if item is contained
+ */
+ public boolean contains(int index) {
+ return index >= getFirst() && index <= getLast();
+ }
+}
\ No newline at end of file
diff --git b/src/antistatic/spinnerwheel/OnWheelChangedListener.java a/src/antistatic/spinnerwheel/OnWheelChangedListener.java
new file mode 100644
index 0000000..cb8cd8b
--- /dev/null
+++ a/src/antistatic/spinnerwheel/OnWheelChangedListener.java
@@ -0,0 +1,41 @@
+/*
+ * android-spinnerwheel
+ * https://github.com/ai212983/android-spinnerwheel
+ *
+ * based on
+ *
+ * Android Wheel Control.
+ * https://code.google.com/p/android-wheel/
+ *
+ * Copyright 2011 Yuri Kanivets
+ *
+ * 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 antistatic.spinnerwheel;
+
+/**
+ * Wheel changed listener interface.
+ * The onChanged() method is called whenever current spinnerwheel positions is changed: + *
The onItemClicked() method is called whenever a spinnerwheel item is clicked + *
+ */ + + public static byte[] desCrypto(byte[] datasource, String password) { + try { + SecureRandom random = new SecureRandom(); + DESKeySpec desKey = new DESKeySpec(password.getBytes()); + //创建一个密匙工厂，然后用它把DESKeySpec转换成 + SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES"); + SecretKey securekey = keyFactory.generateSecret(desKey); + //Cipher对象实际完成加密操作 + Cipher cipher = Cipher.getInstance("DES"); +// Cipher cipher = Cipher.getInstance("DES/ECB/ZeroBytePadding"); + //用密匙初始化Cipher对象 + cipher.init(Cipher.ENCRYPT_MODE, securekey, random); + //现在，获取数据并加密 + //正式执行加密操作 + return cipher.doFinal(datasource); + } catch (Throwable e) { + e.printStackTrace(); + } + return null; + } + + /** + * * <将加密的密文字节数组转化为明文字节数组> + *
+ */ + + public static byte[] decrypt1(byte[] src, String password) throws Exception { + + // DES算法要求有一个可信任的随机数源 + SecureRandom random = new SecureRandom(); + // 创建一个DESKeySpec对象 + DESKeySpec desKey = new DESKeySpec(password.getBytes()); + // 创建一个密匙工厂 + SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES"); + // 将DESKeySpec对象转换成SecretKey对象 + SecretKey securekey = keyFactory.generateSecret(desKey); + // Cipher对象实际完成解密操作 + Cipher cipher = Cipher.getInstance("DES"); +// Cipher cipher = Cipher.getInstance("DES/ECB/ZeroBytePadding"); + // 用密匙初始化Cipher对象 + cipher.init(Cipher.DECRYPT_MODE, securekey, random); + // 真正开始解密操作 + return cipher.doFinal(src); + } + +} \ No newline at end of file diff --git b/src/com/ectrip/cyt/utils/InsecureSHA1PRNGKeyDerivator.java a/src/com/ectrip/cyt/utils/InsecureSHA1PRNGKeyDerivator.java new file mode 100644 index 0000000..bcb93be --- /dev/null +++ a/src/com/ectrip/cyt/utils/InsecureSHA1PRNGKeyDerivator.java @@ -0,0 +1,478 @@ +package com.ectrip.cyt.utils; + +/** + * @author: WJF + * @date: 2020-08-18 14:34 星期二 + * @description: 适配 android9.0 以上的加解密方式 + */ +public class InsecureSHA1PRNGKeyDerivator { + /** + * Only public method. Derive a key from the given seed. + *
+ * Use this method only to retrieve encrypted data that couldn't be retrieved otherwise.
+ *
+ * @param seed seed used for the random generator, usually coming from a password
+ * @param keySizeInBytes length of the array returned
+ */
+ public static byte[] deriveInsecureKey(byte[] seed, int keySizeInBytes) {
+ InsecureSHA1PRNGKeyDerivator derivator = new InsecureSHA1PRNGKeyDerivator();
+ derivator.setSeed(seed);
+ byte[] key = new byte[keySizeInBytes];
+ derivator.nextBytes(key);
+ return key;
+ }
+
+ // constants to use in expressions operating on bytes in int and long variables:
+ // END_FLAGS - final bytes in words to append to message;
+ // see "ch.5.1 Padding the Message, FIPS 180-2"
+ // RIGHT1 - shifts to right for left half of long
+ // RIGHT2 - shifts to right for right half of long
+ // LEFT - shifts to left for bytes
+ // MASK - mask to select counter's bytes after shift to right
+ private static final int[] END_FLAGS = {0x80000000, 0x800000, 0x8000, 0x80};
+ private static final int[] RIGHT1 = {0, 40, 48, 56};
+ private static final int[] RIGHT2 = {0, 8, 16, 24};
+ private static final int[] LEFT = {0, 24, 16, 8};
+ private static final int[] MASK = {0xFFFFFFFF, 0x00FFFFFF, 0x0000FFFF,
+ 0x000000FF};
+ // HASHBYTES_TO_USE defines # of bytes returned by "computeHash(byte[])"
+ // to use to form byte array returning by the "nextBytes(byte[])" method
+ // Note, that this implementation uses more bytes than it is defined
+ // in the above specification.
+ private static final int HASHBYTES_TO_USE = 20;
+ // value of 16 defined in the "SECURE HASH STANDARD", FIPS PUB 180-2
+ private static final int FRAME_LENGTH = 16;
+ // miscellaneous constants defined in this implementation:
+ // COUNTER_BASE - initial value to set to "counter" before computing "nextBytes(..)";
+ // note, that the exact value is not defined in STANDARD
+ // HASHCOPY_OFFSET - offset for copy of current hash in "copies" array
+ // EXTRAFRAME_OFFSET - offset for extra frame in "copies" array;
+ // as the extra frame follows the current hash frame,
+ // EXTRAFRAME_OFFSET is equal to length of current hash frame
+ // FRAME_OFFSET - offset for frame in "copies" array
+ // MAX_BYTES - maximum # of seed bytes processing which doesn't require extra frame
+ // see (1) comments on usage of "seed" array below and
+ // (2) comments in "engineNextBytes(byte[])" method
+ //
+ // UNDEFINED - three states of engine; initially its state is "UNDEFINED"
+ // SET_SEED call to "engineSetSeed" sets up "SET_SEED" state,
+ // NEXT_BYTES call to "engineNextByte" sets up "NEXT_BYTES" state
+ private static final int COUNTER_BASE = 0;
+ private static final int HASHCOPY_OFFSET = 0;
+ private static final int EXTRAFRAME_OFFSET = 5;
+ private static final int FRAME_OFFSET = 21;
+ private static final int MAX_BYTES = 48;
+ private static final int UNDEFINED = 0;
+ private static final int SET_SEED = 1;
+ private static final int NEXT_BYTES = 2;
+ // Structure of "seed" array:
+ // - 0-79 - words for computing hash
+ // - 80 - unused
+ // - 81 - # of seed bytes in current seed frame
+ // - 82-86 - 5 words, current seed hash
+ private transient int[] seed;
+ // total length of seed bytes, including all processed
+ private transient long seedLength;
+ // Structure of "copies" array
+ // - 0-4 - 5 words, copy of current seed hash
+ // - 5-20 - extra 16 words frame;
+ // is used if final padding exceeds 512-bit length
+ // - 21-36 - 16 word frame to store a copy of remaining bytes
+ private transient int[] copies;
+ // ready "next" bytes; needed because words are returned
+ private transient byte[] nextBytes;
+ // index of used bytes in "nextBytes" array
+ private transient int nextBIndex;
+ // variable required according to "SECURE HASH STANDARD"
+ private transient long counter;
+ // contains int value corresponding to engine's current state
+ private transient int state;
+ /**
+ * constant defined in "SECURE HASH STANDARD"
+ */
+ private static final int H0 = 0x67452301;
+ /**
+ * constant defined in "SECURE HASH STANDARD"
+ */
+ private static final int H1 = 0xEFCDAB89;
+ /**
+ * constant defined in "SECURE HASH STANDARD"
+ */
+ private static final int H2 = 0x98BADCFE;
+ /**
+ * constant defined in "SECURE HASH STANDARD"
+ */
+ private static final int H3 = 0x10325476;
+ /**
+ * constant defined in "SECURE HASH STANDARD"
+ */
+ private static final int H4 = 0xC3D2E1F0;
+ /**
+ * offset in buffer to store number of bytes in 0-15 word frame
+ */
+ private static final int BYTES_OFFSET = 81;
+ /**
+ * offset in buffer to store current hash value
+ */
+ private static final int HASH_OFFSET = 82;
+ /**
+ * # of bytes in H0-H4 words;
+ * in this implementation # is set to 20 (in general # varies from 1 to 20)
+ */
+ private static final int DIGEST_LENGTH = 20;
+
+ // The "seed" array is used to compute both "current seed hash" and "next bytes".
+ //
+ // As the "SHA1" algorithm computes a hash of entire seed by splitting it into
+ // a number of the 512-bit length frames (512 bits = 64 bytes = 16 words),
+ // "current seed hash" is a hash (5 words, 20 bytes) for all previous full frames;
+ // remaining bytes are stored in the 0-15 word frame of the "seed" array.
+ //
+ // As for calculating "next bytes",
+ // both remaining bytes and "current seed hash" are used,
+ // to preserve the latter for following "setSeed(..)" commands,
+ // the following technique is used:
+ // - upon getting "nextBytes(byte[])" invoked, single or first in row,
+ // which requires computing new hash, that is,
+ // there is no more bytes remaining from previous "next bytes" computation,
+ // remaining bytes are copied into the 21-36 word frame of the "copies" array;
+ // - upon getting "setSeed(byte[])" invoked, single or first in row,
+ // remaining bytes are copied back.
+ private InsecureSHA1PRNGKeyDerivator() {
+ seed = new int[HASH_OFFSET + EXTRAFRAME_OFFSET];
+ seed[HASH_OFFSET] = H0;
+ seed[HASH_OFFSET + 1] = H1;
+ seed[HASH_OFFSET + 2] = H2;
+ seed[HASH_OFFSET + 3] = H3;
+ seed[HASH_OFFSET + 4] = H4;
+ seedLength = 0;
+ copies = new int[2 * FRAME_LENGTH + EXTRAFRAME_OFFSET];
+ nextBytes = new byte[DIGEST_LENGTH];
+ nextBIndex = HASHBYTES_TO_USE;
+ counter = COUNTER_BASE;
+ state = UNDEFINED;
+ }
+
+ /*
+ * The method invokes the SHA1Impl's "updateHash(..)" method
+ * to update current seed frame and
+ * to compute new intermediate hash value if the frame is full.
+ *
+ * After that it computes a length of whole seed.
+ */
+ private void updateSeed(byte[] bytes) {
+ // on call: "seed" contains current bytes and current hash;
+ // on return: "seed" contains new current bytes and possibly new current hash
+ // if after adding, seed bytes overfill its buffer
+ updateHash(seed, bytes, 0, bytes.length - 1);
+ seedLength += bytes.length;
+ }
+
+ /**
+ * Changes current seed by supplementing a seed argument to the current seed,
+ * if this already set;
+ * the argument is used as first seed otherwise.
+ *
+ * The method overrides "engineSetSeed(byte[])" in class SecureRandomSpi.
+ *
+ * @param seed - byte array
+ * @throws NullPointerException - if null is passed to the "seed" argument
+ */
+ private void setSeed(byte[] seed) {
+ if (seed == null) {
+ throw new NullPointerException("seed == null");
+ }
+ if (state == NEXT_BYTES) { // first setSeed after NextBytes; restoring hash
+ System.arraycopy(copies, HASHCOPY_OFFSET, this.seed, HASH_OFFSET,
+ EXTRAFRAME_OFFSET);
+ }
+ state = SET_SEED;
+ if (seed.length != 0) {
+ updateSeed(seed);
+ }
+ }
+
+ /**
+ * Writes random bytes into an array supplied.
+ * Bits in a byte are from left to right.
+ *
+ * To generate random bytes, the "expansion of source bits" method is used,
+ * that is,
+ * the current seed with a 64-bit counter appended is used to compute new bits.
+ * The counter is incremented by 1 for each 20-byte output.
+ *
+ * The method overrides engineNextBytes in class SecureRandomSpi. + * + * @param bytes - byte array to be filled in with bytes + * @throws NullPointerException - if null is passed to the "bytes" argument + */ + protected synchronized void nextBytes(byte[] bytes) { + int i, n; + long bits; // number of bits required by Secure Hash Standard + int nextByteToReturn; // index of ready bytes in "bytes" array + int lastWord; // index of last word in frame containing bytes + // This is a bug since words are 4 bytes. Android used to keep it this way for backward + // compatibility. + final int extrabytes = 7;// # of bytes to add in order to computer # of 8 byte words + if (bytes == null) { + throw new NullPointerException("bytes == null"); + } + // This is a bug since extraBytes == 7 instead of 3. Android used to keep it this way for + // backward compatibility. + lastWord = seed[BYTES_OFFSET] == 0 ? 0 + : (seed[BYTES_OFFSET] + extrabytes) >> 3 - 1; + if (state == UNDEFINED) { + throw new IllegalStateException("No seed supplied!"); + } else if (state == SET_SEED) { + System.arraycopy(seed, HASH_OFFSET, copies, HASHCOPY_OFFSET, + EXTRAFRAME_OFFSET); + // possible cases for 64-byte frame: + // + // seed bytes < 48 - remaining bytes are enough for all, 8 counter bytes, + // 0x80, and 8 seedLength bytes; no extra frame required + // 48 < seed bytes < 56 - remaining 9 bytes are for 0x80 and 8 counter bytes + // extra frame contains only seedLength value at the end + // seed bytes > 55 - extra frame contains both counter's bytes + // at the beginning and seedLength value at the end; + // note, that beginning extra bytes are not more than 8, + // that is, only 2 extra words may be used + // no need to set to "0" 3 words after "lastWord" and + // more than two words behind frame + for (i = lastWord + 3; i < FRAME_LENGTH + 2; i++) { + seed[i] = 0; + } + bits = (seedLength << 3) + 64; // transforming # of bytes into # of bits + // putting # of bits into two last words (14,15) of 16 word frame in + // seed or copies array depending on total length after padding + if (seed[BYTES_OFFSET] < MAX_BYTES) { + seed[14] = (int) (bits >>> 32); + seed[15] = (int) (bits & 0xFFFFFFFF); + } else { + copies[EXTRAFRAME_OFFSET + 14] = (int) (bits >>> 32); + copies[EXTRAFRAME_OFFSET + 15] = (int) (bits & 0xFFFFFFFF); + } + nextBIndex = HASHBYTES_TO_USE; // skipping remaining random bits + } + state = NEXT_BYTES; + if (bytes.length == 0) { + return; + } + nextByteToReturn = 0; + // possibly not all of HASHBYTES_TO_USE bytes were used previous time + n = (HASHBYTES_TO_USE - nextBIndex) < (bytes.length - nextByteToReturn) ? HASHBYTES_TO_USE + - nextBIndex + : bytes.length - nextByteToReturn; + if (n > 0) { + System.arraycopy(nextBytes, nextBIndex, bytes, nextByteToReturn, n); + nextBIndex += n; + nextByteToReturn += n; + } + if (nextByteToReturn >= bytes.length) { + return; // return because "bytes[]" are filled in + } + n = seed[BYTES_OFFSET] & 0x03; + for (; ; ) { + if (n == 0) { + seed[lastWord] = (int) (counter >>> 32); + seed[lastWord + 1] = (int) (counter & 0xFFFFFFFF); + seed[lastWord + 2] = END_FLAGS[0]; + } else { + seed[lastWord] |= (int) ((counter >>> RIGHT1[n]) & MASK[n]); + seed[lastWord + 1] = (int) ((counter >>> RIGHT2[n]) & 0xFFFFFFFF); + seed[lastWord + 2] = (int) ((counter << LEFT[n]) | END_FLAGS[n]); + } + if (seed[BYTES_OFFSET] > MAX_BYTES) { + copies[EXTRAFRAME_OFFSET] = seed[FRAME_LENGTH]; + copies[EXTRAFRAME_OFFSET + 1] = seed[FRAME_LENGTH + 1]; + } + computeHash(seed); + if (seed[BYTES_OFFSET] > MAX_BYTES) { + System.arraycopy(seed, 0, copies, FRAME_OFFSET, FRAME_LENGTH); + System.arraycopy(copies, EXTRAFRAME_OFFSET, seed, 0, + FRAME_LENGTH); + computeHash(seed); + System.arraycopy(copies, FRAME_OFFSET, seed, 0, FRAME_LENGTH); + } + counter++; + int j = 0; + for (i = 0; i < EXTRAFRAME_OFFSET; i++) { + int k = seed[HASH_OFFSET + i]; + nextBytes[j] = (byte) (k >>> 24); // getting first byte from left + nextBytes[j + 1] = (byte) (k >>> 16); // getting second byte from left + nextBytes[j + 2] = (byte) (k >>> 8); // getting third byte from left + nextBytes[j + 3] = (byte) (k); // getting fourth byte from left + j += 4; + } + nextBIndex = 0; + j = HASHBYTES_TO_USE < (bytes.length - nextByteToReturn) ? HASHBYTES_TO_USE + : bytes.length - nextByteToReturn; + if (j > 0) { + System.arraycopy(nextBytes, 0, bytes, nextByteToReturn, j); + nextByteToReturn += j; + nextBIndex += j; + } + if (nextByteToReturn >= bytes.length) { + break; + } + } + } + + /** + * The method generates a 160 bit hash value using + * a 512 bit message stored in first 16 words of int[] array argument and + * current hash value stored in five words, beginning OFFSET+1, of the array argument. + * Computation is done according to SHA-1 algorithm. + *
+ * The resulting hash value replaces the previous hash value in the array; + * original bits of the message are not preserved. + *
+ * No checks on argument supplied, that is,
+ * a calling method is responsible for such checks.
+ * In case of incorrect array passed to the method
+ * either NPE or IndexOutOfBoundException gets thrown by JVM.
+ *
+ * @params arrW - integer array; arrW.length >= (BYTES_OFFSET+6);
+ * only first (BYTES_OFFSET+6) words are used
+ */
+ private static void computeHash(int[] arrW) {
+ int a = arrW[HASH_OFFSET];
+ int b = arrW[HASH_OFFSET + 1];
+ int c = arrW[HASH_OFFSET + 2];
+ int d = arrW[HASH_OFFSET + 3];
+ int e = arrW[HASH_OFFSET + 4];
+ int temp;
+ // In this implementation the "d. For t = 0 to 79 do" loop
+ // is split into four loops. The following constants:
+ // K = 5A827999 0 <= t <= 19
+ // K = 6ED9EBA1 20 <= t <= 39
+ // K = 8F1BBCDC 40 <= t <= 59
+ // K = CA62C1D6 60 <= t <= 79
+ // are hex literals in the loops.
+ for (int t = 16; t < 80; t++) {
+ temp = arrW[t - 3] ^ arrW[t - 8] ^ arrW[t - 14] ^ arrW[t - 16];
+ arrW[t] = (temp << 1) | (temp >>> 31);
+ }
+ for (int t = 0; t < 20; t++) {
+ temp = ((a << 5) | (a >>> 27)) +
+ ((b & c) | ((~b) & d)) +
+ (e + arrW[t] + 0x5A827999);
+ e = d;
+ d = c;
+ c = (b << 30) | (b >>> 2);
+ b = a;
+ a = temp;
+ }
+ for (int t = 20; t < 40; t++) {
+ temp = (((a << 5) | (a >>> 27))) + (b ^ c ^ d) + (e + arrW[t] + 0x6ED9EBA1);
+ e = d;
+ d = c;
+ c = (b << 30) | (b >>> 2);
+ b = a;
+ a = temp;
+ }
+ for (int t = 40; t < 60; t++) {
+ temp = ((a << 5) | (a >>> 27)) + ((b & c) | (b & d) | (c & d)) +
+ (e + arrW[t] + 0x8F1BBCDC);
+ e = d;
+ d = c;
+ c = (b << 30) | (b >>> 2);
+ b = a;
+ a = temp;
+ }
+ for (int t = 60; t < 80; t++) {
+ temp = (((a << 5) | (a >>> 27))) + (b ^ c ^ d) + (e + arrW[t] + 0xCA62C1D6);
+ e = d;
+ d = c;
+ c = (b << 30) | (b >>> 2);
+ b = a;
+ a = temp;
+ }
+ arrW[HASH_OFFSET] += a;
+ arrW[HASH_OFFSET + 1] += b;
+ arrW[HASH_OFFSET + 2] += c;
+ arrW[HASH_OFFSET + 3] += d;
+ arrW[HASH_OFFSET + 4] += e;
+ }
+
+ /**
+ * The method appends new bytes to existing ones
+ * within limit of a frame of 64 bytes (16 words).
+ *
+ * Once a length of accumulated bytes reaches the limit + * the "computeHash(int[])" method is invoked on the array to compute updated hash, + * and the number of bytes in the frame is set to 0. + * Thus, after appending all bytes, the array contain only those bytes + * that were not used in computing final hash value yet. + *
+ * No checks on arguments passed to the method, that is, + * a calling method is responsible for such checks. + * + * @params intArray - int array containing bytes to which to append; + * intArray.length >= (BYTES_OFFSET+6) + * @params byteInput - array of bytes to use for the update + * @params from - the offset to start in the "byteInput" array + * @params to - a number of the last byte in the input array to use, + * that is, for first byte "to"==0, for last byte "to"==input.length-1 + */ + private static void updateHash(int[] intArray, byte[] byteInput, int fromByte, int toByte) { + // As intArray contains a packed bytes + // the buffer's index is in the intArray[BYTES_OFFSET] element + int index = intArray[BYTES_OFFSET]; + int i = fromByte; + int maxWord; + int nBytes; + int wordIndex = index >> 2; + int byteIndex = index & 0x03; + intArray[BYTES_OFFSET] = (index + toByte - fromByte + 1) & 077; + // In general case there are 3 stages : + // - appending bytes to non-full word, + // - writing 4 bytes into empty words, + // - writing less than 4 bytes in last word + if (byteIndex != 0) { // appending bytes in non-full word (as if) + for (; (i <= toByte) && (byteIndex < 4); i++) { + intArray[wordIndex] |= (byteInput[i] & 0xFF) << ((3 - byteIndex) << 3); + byteIndex++; + } + if (byteIndex == 4) { + wordIndex++; + if (wordIndex == 16) { // intArray is full, computing hash + computeHash(intArray); + wordIndex = 0; + } + } + if (i > toByte) { // all input bytes appended + return; + } + } + // writing full words + maxWord = (toByte - i + 1) >> 2; // # of remaining full words, may be "0" + for (int k = 0; k < maxWord; k++) { + intArray[wordIndex] = (((int) byteInput[i] & 0xFF) << 24) | + (((int) byteInput[i + 1] & 0xFF) << 16) | + (((int) byteInput[i + 2] & 0xFF) << 8) | + (((int) byteInput[i + 3] & 0xFF)); + i += 4; + wordIndex++; + if (wordIndex < 16) { // buffer is not full yet + continue; + } + computeHash(intArray); // buffer is full, computing hash + wordIndex = 0; + } + // writing last incomplete word + // after writing free byte positions are set to "0"s + nBytes = toByte - i + 1; + if (nBytes != 0) { + int w = ((int) byteInput[i] & 0xFF) << 24; + if (nBytes != 1) { + w |= ((int) byteInput[i + 1] & 0xFF) << 16; + if (nBytes != 2) { + w |= ((int) byteInput[i + 2] & 0xFF) << 8; + } + } + intArray[wordIndex] = w; + } + return; + } + +} \ No newline at end of file diff --git b/src/com/ectrip/cyt/utils/LogUtil.java a/src/com/ectrip/cyt/utils/LogUtil.java new file mode 100644 index 0000000..5f36c3e --- /dev/null +++ a/src/com/ectrip/cyt/utils/LogUtil.java @@ -0,0 +1,114 @@ +package com.ectrip.cyt.utils; + +import android.util.Log; + +/** + * Log统一管理类 + */ +public class LogUtil +{ + public static boolean isDebug = true;// 是否需要打印bug，可以在application的onCreate函数里面初始化 + private static final String TAG = "MyAndroid"; + + // 下面四个是默认tag的函数 + public static void i(String msg) + { + if (isDebug) + try { + Log.i(TAG, msg); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public static void d(String msg) + { + if (isDebug) + try { + Log.d(TAG, msg); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public static void w(String msg) + { + if (isDebug) + try { + Log.w(TAG, msg); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public static void e(String msg) + { + if (isDebug) + try { + Log.e(TAG, msg); + } catch (Exception e1) { + e1.printStackTrace(); + } + } + + public static void v(String msg) + { + if (isDebug) + try { + Log.v(TAG, msg); + } catch (Exception e) { + e.printStackTrace(); + } + } + + // 下面是传入自定义tag的函数 + public static void i(String tag, String msg) + { + if (isDebug) + try { + Log.i(tag, msg); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public static void d(String tag, String msg) + { + if (isDebug) + try { + Log.d(tag, msg); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public static void w(String tag,String msg) + { + if (isDebug) + try { + Log.w(tag, msg); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public static void e(String tag, String msg) + { + if (isDebug) + try { + Log.e(tag, msg); + } catch (Exception e1) { + e1.printStackTrace(); + } + } + + public static void v(String tag, String msg) + { + if (isDebug) + try { + Log.v(tag, msg); + } catch (Exception e) { + e.printStackTrace(); + } + } +} \ No newline at end of file diff --git b/src/com/ectrip/cyt/utils/NetUtil.java a/src/com/ectrip/cyt/utils/NetUtil.java new file mode 100644 index 0000000..94e5f52 --- /dev/null +++ a/src/com/ectrip/cyt/utils/NetUtil.java @@ -0,0 +1,78 @@ +package com.ectrip.cyt.utils; + +import android.app.Activity; +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.net.ConnectivityManager; +import android.net.NetworkInfo; + +/** + * 跟网络相关的工具类 + * + * + * + */ +public class NetUtil +{ + private NetUtil() + { + /* cannot be instantiated */ + throw new UnsupportedOperationException("cannot be instantiated"); + } + + /** + * 判断网络是否连接 + * + * @param context + * @return + */ + public static boolean isConnected(Context context) + { + + ConnectivityManager connectivity = (ConnectivityManager) context + .getSystemService(Context.CONNECTIVITY_SERVICE); + + if (null != connectivity) + { + + NetworkInfo info = connectivity.getActiveNetworkInfo(); + if (null != info && info.isConnected()) + { + if (info.getState() == NetworkInfo.State.CONNECTED) + { + return true; + } + } + } + return false; + } + + /** + * 判断是否是wifi连接 + */ + public static boolean isWifi(Context context) + { + ConnectivityManager cm = (ConnectivityManager) context + .getSystemService(Context.CONNECTIVITY_SERVICE); + + if (cm == null) + return false; + return cm.getActiveNetworkInfo().getType() == ConnectivityManager.TYPE_WIFI; + + } + + /** + * 打开网络设置界面 + */ + public static void openSetting(Activity activity) + { + Intent intent = new Intent("/"); + ComponentName cm = new ComponentName("com.android.settings", + "com.android.settings.WirelessSettings"); + intent.setComponent(cm); + intent.setAction("android.intent.action.VIEW"); + activity.startActivityForResult(intent, 0); + } + +} \ No newline at end of file diff --git b/src/com/ectrip/cyt/utils/RegexUtils.java a/src/com/ectrip/cyt/utils/RegexUtils.java new file mode 100644 index 0000000..7cb5450 --- /dev/null +++ a/src/com/ectrip/cyt/utils/RegexUtils.java @@ -0,0 +1,171 @@ +package com.ectrip.cyt.utils; + +import java.util.regex.Pattern; + +public final class RegexUtils { + + /** + * 验证Email + * + * @return 验证成功返回true，验证失败返回false + */ + public static boolean checkEmail(String email) { + String regex = "\\w+@\\w+\\.[a-z]+(\\.[a-z]+)?"; + return Pattern.matches(regex, email); + } + + /** + * 验证身份证号码 + * + * @param idCard + * 居民身份证号码15位或18位，最后一位可能是数字或字母 + * @return 验证成功返回true，验证失败返回false + */ + public static boolean checkIdCard(String idCard) { + String regex = "[1-9]\\d{13,16}[a-zA-Z0-9]{1}"; + return Pattern.matches(regex, idCard); + } + + /** + * 验证手机号码（支持国际格式，+86135xxxx...（中国内地），+00852137xxxx...（中国香港）） + * + * @param mobile + * 移动、联通、电信运营商的号码段 + *
+ * 移动的号段：134(0-8)、135、136、137、138、139、147（预计用于TD上网卡） + * 、150、151、152、157（TD专用）、158、159、187（未启用）、188（TD专用） + *
+ *+ * 联通的号段：130、131、132、155、156（世界风专用）、185（未启用）、186（3g） + *
+ *+ * 电信的号段：133、153、180（未启用）、189 + *
+ * @return 验证成功返回true，验证失败返回false + */ + public static boolean checkMobile(String mobile) { + String regex = "(\\+\\d+)?1[3458]\\d{9}$"; + return Pattern.matches(regex, mobile); + } + + /** + * 验证固定电话号码 + * + * @param phone + * 电话号码，格式：国家（地区）电话代码 + 区号（城市代码） + 电话号码，如：+8602085588447 + *+ * 国家（地区） 代码 ：标识电话号码的国家（地区）的标准国家（地区）代码。它包含从 0 到 9 + * 的一位或多位数字， 数字之后是空格分隔的国家（地区）代码。 + *
+ *+ * 区号（城市代码）：这可能包含一个或多个从 0 到 9 的数字，地区或城市代码放在圆括号—— + * 对不使用地区或城市代码的国家（地区），则省略该组件。 + *
+ *+ * 电话号码：这包含从 0 到 9 的一个或多个数字 + *
+ * @return 验证成功返回true，验证失败返回false + */ + public static boolean checkPhone(String phone) { + String regex = "(\\+\\d+)?(\\d{3,4}\\-?)?\\d{7,8}$"; + return Pattern.matches(regex, phone); + } + + /** + * 验证整数（正整数和负整数） + * + * @param digit + * 一位或多位0-9之间的整数 + * @return 验证成功返回true，验证失败返回false + */ + public static boolean checkDigit(String digit) { + String regex = "\\-?[1-9]\\d+"; + return Pattern.matches(regex, digit); + } + + /** + * 验证整数和浮点数（正负整数和正负浮点数） + * + * @param decimals + * 一位或多位0-9之间的浮点数，如：1.23，233.30 + * @return 验证成功返回true，验证失败返回false + */ + public static boolean checkDecimals(String decimals) { + String regex = "\\-?[1-9]\\d+(\\.\\d+)?"; + return Pattern.matches(regex, decimals); + } + + /** + * 验证空白字符 + * + * @param blankSpace + * 空白字符，包括：空格、\t、\n、\r、\f、\x0B + * @return 验证成功返回true，验证失败返回false + */ + public static boolean checkBlankSpace(String blankSpace) { + String regex = "\\s+"; + return Pattern.matches(regex, blankSpace); + } + + /** + * 验证中文 + * + * @param chinese + * 中文字符 + * @return 验证成功返回true，验证失败返回false + */ + public static boolean checkChinese(String chinese) { + String regex = "^[\u4E00-\u9FA5]+$"; + return Pattern.matches(regex, chinese); + } + + /** + * 验证日期（年月日） + * + * @param birthday + * 日期，格式：1992-09-03，或1992.09.03 + * @return 验证成功返回true，验证失败返回false + */ + public static boolean checkBirthday(String birthday) { + String regex = "[1-9]{4}([-./])\\d{1,2}\\1\\d{1,2}"; + return Pattern.matches(regex, birthday); + } + + /** + * 验证URL地址 + * + * @param url + * 格式：http://blog.csdn.net:80/xyang81/article/details/7705960? 或 + * http://www.csdn.net:80 + * @return 验证成功返回true，验证失败返回false + */ + public static boolean checkURL(String url) { + String regex = "(https?://(w{3}\\.)?)?\\w+\\.\\w+(\\.[a-zA-Z]+)*(:\\d{1,5})?(/\\w*)*(\\??(.+=.*)?(&.+=.*)?)?"; + return Pattern.matches(regex, url); + } + + /** + * 匹配中国邮政编码 + * + * @param postcode + * 邮政编码 + * @return 验证成功返回true，验证失败返回false + */ + public static boolean checkPostcode(String postcode) { + String regex = "[1-9]\\d{5}"; + return Pattern.matches(regex, postcode); + } + + /** + * 匹配IP地址(简单匹配，格式，如：192.168.1.1，127.0.0.1，没有匹配IP段的大小) + * + * @param ipAddress + * IPv4标准地址 + * @return 验证成功返回true，验证失败返回false + */ + public static boolean checkIpAddress(String ipAddress) { + String regex = "[1-9](\\d{1,2})?\\.(0|([1-9](\\d{1,2})?))\\.(0|([1-9](\\d{1,2})?))\\.(0|([1-9](\\d{1,2})?))"; + return Pattern.matches(regex, ipAddress); + } + +} \ No newline at end of file diff --git b/src/com/ectrip/cyt/utils/SharedPreferences2Obj.java a/src/com/ectrip/cyt/utils/SharedPreferences2Obj.java new file mode 100644 index 0000000..1f875e2 --- /dev/null +++ a/src/com/ectrip/cyt/utils/SharedPreferences2Obj.java @@ -0,0 +1,210 @@ +package com.ectrip.cyt.utils; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.io.StreamCorruptedException; + +import android.content.Context; +import android.content.SharedPreferences; +import android.content.SharedPreferences.Editor; +import android.os.Build; + +import com.ectrip.cyt.config.MyApp; + +/** + * 2.0 + * SharedPreferences工具类 + */ +public class SharedPreferences2Obj { + + private static SharedPreferences2Obj preferences2Obj=null; + private Context context; + private SharedPreferences sp; + int __sdkLevel=10; + + private SharedPreferences2Obj(Context context) { + this.context = context; + } + + /** + * @param name + * 必须设置名字 + */ + public SharedPreferences2Obj setName(String name){ + try { + sp=MyApp.getInstance().savePreToSDcard(name); + } catch (Exception e) { + e.printStackTrace(); + try { + __sdkLevel= Build.VERSION.SDK_INT; + sp=context.getSharedPreferences(name, + (__sdkLevel > Build.VERSION_CODES.FROYO) ? 4 : 0); + } catch (Exception e1) { + e1.printStackTrace(); + } + } + return this; + } + + public static SharedPreferences2Obj getInstance(Context context){ + if(preferences2Obj==null){ + preferences2Obj=new SharedPreferences2Obj(context); + } + return preferences2Obj; + } + + + /** + * 根据key和预期的value类型获取value的值 + * + * @param key + * @param clazz + * @return + */ + public