forked from upstream-mirrors/quik
Merge branch 'dev' of https://github.com/moezbhatti/qksms into dev
This commit is contained in:
@@ -1,227 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2011 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 android.net;
|
||||
|
||||
import android.content.Context;
|
||||
import android.net.wifi.WifiInfo;
|
||||
import android.net.wifi.WifiManager;
|
||||
import android.os.Build;
|
||||
import android.telephony.TelephonyManager;
|
||||
import com.android.internal.util.Objects;
|
||||
|
||||
import static android.net.ConnectivityManager.TYPE_WIFI;
|
||||
|
||||
/**
|
||||
* Network definition that includes strong identity. Analogous to combining
|
||||
* {@link NetworkInfo} and an IMSI.
|
||||
*
|
||||
* @hide
|
||||
*/
|
||||
public class NetworkIdentity {
|
||||
/**
|
||||
* When enabled, combine all {@link #mSubType} together under
|
||||
* {@link #SUBTYPE_COMBINED}.
|
||||
*/
|
||||
public static final boolean COMBINE_SUBTYPE_ENABLED = true;
|
||||
|
||||
public static final int SUBTYPE_COMBINED = -1;
|
||||
|
||||
final int mType;
|
||||
final int mSubType;
|
||||
final String mSubscriberId;
|
||||
final String mNetworkId;
|
||||
final boolean mRoaming;
|
||||
|
||||
public NetworkIdentity(
|
||||
int type, int subType, String subscriberId, String networkId, boolean roaming) {
|
||||
mType = type;
|
||||
mSubType = COMBINE_SUBTYPE_ENABLED ? SUBTYPE_COMBINED : subType;
|
||||
mSubscriberId = subscriberId;
|
||||
mNetworkId = networkId;
|
||||
mRoaming = roaming;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@hide}
|
||||
*/
|
||||
public static String getNetworkTypeName(int type) {
|
||||
switch (type) {
|
||||
case 0:
|
||||
return "MOBILE";
|
||||
case TYPE_WIFI:
|
||||
return "WIFI";
|
||||
case 2:
|
||||
return "MOBILE_MMS";
|
||||
case 3:
|
||||
return "MOBILE_SUPL";
|
||||
case 4:
|
||||
return "MOBILE_DUN";
|
||||
case 5:
|
||||
return "MOBILE_HIPRI";
|
||||
case 6:
|
||||
return "WIMAX";
|
||||
case 7:
|
||||
return "BLUETOOTH";
|
||||
case 8:
|
||||
return "DUMMY";
|
||||
case 9:
|
||||
return "ETHERNET";
|
||||
case 10:
|
||||
return "MOBILE_FOTA";
|
||||
case 11:
|
||||
return "MOBILE_IMS";
|
||||
case 12:
|
||||
return "MOBILE_CBS";
|
||||
case 13:
|
||||
return "WIFI_P2P";
|
||||
default:
|
||||
return Integer.toString(type);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@hide}
|
||||
*/
|
||||
public static boolean isNetworkTypeMobile(int networkType) {
|
||||
switch (networkType) {
|
||||
case 0:
|
||||
case 2:
|
||||
case 3:
|
||||
case 4:
|
||||
case 5:
|
||||
case 10:
|
||||
case 11:
|
||||
case 12:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return Objects.hashCode(mType, mSubType, mSubscriberId, mNetworkId, mRoaming);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
if (obj instanceof NetworkIdentity) {
|
||||
final NetworkIdentity ident = (NetworkIdentity) obj;
|
||||
return mType == ident.mType && mSubType == ident.mSubType && mRoaming == ident.mRoaming
|
||||
&& Objects.equal(mSubscriberId, ident.mSubscriberId)
|
||||
&& Objects.equal(mNetworkId, ident.mNetworkId);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
final StringBuilder builder = new StringBuilder("[");
|
||||
builder.append("type=").append(getNetworkTypeName(mType));
|
||||
builder.append(", subType=");
|
||||
if (COMBINE_SUBTYPE_ENABLED) {
|
||||
builder.append("COMBINED");
|
||||
} else if (isNetworkTypeMobile(mType)) {
|
||||
builder.append(getNetworkTypeName(mSubType));
|
||||
} else {
|
||||
builder.append(mSubType);
|
||||
}
|
||||
if (mSubscriberId != null) {
|
||||
builder.append(", subscriberId=").append(scrubSubscriberId(mSubscriberId));
|
||||
}
|
||||
if (mNetworkId != null) {
|
||||
builder.append(", networkId=").append(mNetworkId);
|
||||
}
|
||||
if (mRoaming) {
|
||||
builder.append(", ROAMING");
|
||||
}
|
||||
return builder.append("]").toString();
|
||||
}
|
||||
|
||||
public int getType() {
|
||||
return mType;
|
||||
}
|
||||
|
||||
public int getSubType() {
|
||||
return mSubType;
|
||||
}
|
||||
|
||||
public String getSubscriberId() {
|
||||
return mSubscriberId;
|
||||
}
|
||||
|
||||
public String getNetworkId() {
|
||||
return mNetworkId;
|
||||
}
|
||||
|
||||
public boolean getRoaming() {
|
||||
return mRoaming;
|
||||
}
|
||||
|
||||
/**
|
||||
* Scrub given IMSI on production builds.
|
||||
*/
|
||||
public static String scrubSubscriberId(String subscriberId) {
|
||||
if ("eng".equals(Build.TYPE)) {
|
||||
return subscriberId;
|
||||
} else if (subscriberId != null) {
|
||||
// TODO: parse this as MCC+MNC instead of hard-coding
|
||||
return subscriberId.substring(0, Math.min(6, subscriberId.length())) + "...";
|
||||
} else {
|
||||
return "null";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Build a {@link NetworkIdentity} from the given {@link NetworkState},
|
||||
* assuming that any mobile networks are using the current IMSI.
|
||||
*/
|
||||
public static NetworkIdentity buildNetworkIdentity(Context context, NetworkState state) {
|
||||
final int type = state.networkInfo.getType();
|
||||
final int subType = state.networkInfo.getSubtype();
|
||||
|
||||
// TODO: consider moving subscriberId over to LinkCapabilities, so it
|
||||
// comes from an authoritative source.
|
||||
|
||||
String subscriberId = null;
|
||||
String networkId = null;
|
||||
boolean roaming = false;
|
||||
|
||||
if (isNetworkTypeMobile(type)) {
|
||||
final TelephonyManager telephony = (TelephonyManager) context.getSystemService(
|
||||
Context.TELEPHONY_SERVICE);
|
||||
roaming = telephony.isNetworkRoaming();
|
||||
if (state.subscriberId != null) {
|
||||
subscriberId = state.subscriberId;
|
||||
} else {
|
||||
subscriberId = telephony.getSubscriberId();
|
||||
}
|
||||
|
||||
} else if (type == TYPE_WIFI) {
|
||||
if (state.networkId != null) {
|
||||
networkId = state.networkId;
|
||||
} else {
|
||||
final WifiManager wifi = (WifiManager) context.getSystemService(
|
||||
Context.WIFI_SERVICE);
|
||||
final WifiInfo info = wifi.getConnectionInfo();
|
||||
networkId = info != null ? info.getSSID() : null;
|
||||
}
|
||||
}
|
||||
|
||||
return new NetworkIdentity(type, subType, subscriberId, networkId, roaming);
|
||||
}
|
||||
}
|
||||
@@ -1,243 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2006 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.internal.util;
|
||||
|
||||
import java.lang.reflect.Array;
|
||||
|
||||
// XXX these should be changed to reflect the actual memory allocator we use.
|
||||
// it looks like right now objects want to be powers of 2 minus 8
|
||||
// and the array size eats another 4 bytes
|
||||
|
||||
/**
|
||||
* ArrayUtils contains some methods that you can call to find out
|
||||
* the most efficient increments by which to grow arrays.
|
||||
*/
|
||||
public class ArrayUtils {
|
||||
private static Object[] EMPTY = new Object[0];
|
||||
private static final int CACHE_SIZE = 73;
|
||||
private static Object[] sCache = new Object[CACHE_SIZE];
|
||||
|
||||
private ArrayUtils() { /* cannot be instantiated */ }
|
||||
|
||||
public static int idealByteArraySize(int need) {
|
||||
for (int i = 4; i < 32; i++)
|
||||
if (need <= (1 << i) - 12)
|
||||
return (1 << i) - 12;
|
||||
|
||||
return need;
|
||||
}
|
||||
|
||||
public static int idealBooleanArraySize(int need) {
|
||||
return idealByteArraySize(need);
|
||||
}
|
||||
|
||||
public static int idealShortArraySize(int need) {
|
||||
return idealByteArraySize(need * 2) / 2;
|
||||
}
|
||||
|
||||
public static int idealCharArraySize(int need) {
|
||||
return idealByteArraySize(need * 2) / 2;
|
||||
}
|
||||
|
||||
public static int idealIntArraySize(int need) {
|
||||
return idealByteArraySize(need * 4) / 4;
|
||||
}
|
||||
|
||||
public static int idealFloatArraySize(int need) {
|
||||
return idealByteArraySize(need * 4) / 4;
|
||||
}
|
||||
|
||||
public static int idealObjectArraySize(int need) {
|
||||
return idealByteArraySize(need * 4) / 4;
|
||||
}
|
||||
|
||||
public static int idealLongArraySize(int need) {
|
||||
return idealByteArraySize(need * 8) / 8;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the beginnings of two byte arrays are equal.
|
||||
*
|
||||
* @param array1 the first byte array
|
||||
* @param array2 the second byte array
|
||||
* @param length the number of bytes to check
|
||||
* @return true if they're equal, false otherwise
|
||||
*/
|
||||
public static boolean equals(byte[] array1, byte[] array2, int length) {
|
||||
if (array1 == array2) {
|
||||
return true;
|
||||
}
|
||||
if (array1 == null || array2 == null || array1.length < length || array2.length < length) {
|
||||
return false;
|
||||
}
|
||||
for (int i = 0; i < length; i++) {
|
||||
if (array1[i] != array2[i]) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an empty array of the specified type. The intent is that
|
||||
* it will return the same empty array every time to avoid reallocation,
|
||||
* although this is not guaranteed.
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public static <T> T[] emptyArray(Class<T> kind) {
|
||||
if (kind == Object.class) {
|
||||
return (T[]) EMPTY;
|
||||
}
|
||||
|
||||
int bucket = ((System.identityHashCode(kind) / 8) & 0x7FFFFFFF) % CACHE_SIZE;
|
||||
Object cache = sCache[bucket];
|
||||
|
||||
if (cache == null || cache.getClass().getComponentType() != kind) {
|
||||
cache = Array.newInstance(kind, 0);
|
||||
sCache[bucket] = cache;
|
||||
|
||||
// Log.e("cache", "new empty " + kind.getName() + " at " + bucket);
|
||||
}
|
||||
|
||||
return (T[]) cache;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks that value is present as at least one of the elements of the array.
|
||||
*
|
||||
* @param array the array to check in
|
||||
* @param value the value to check for
|
||||
* @return true if the value is present in the array
|
||||
*/
|
||||
public static <T> boolean contains(T[] array, T value) {
|
||||
for (T element : array) {
|
||||
if (element == null) {
|
||||
if (value == null) return true;
|
||||
} else {
|
||||
if (value != null && element.equals(value)) return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public static boolean contains(int[] array, int value) {
|
||||
for (int element : array) {
|
||||
if (element == value) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public static long total(long[] array) {
|
||||
long total = 0;
|
||||
for (long value : array) {
|
||||
total += value;
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
/**
|
||||
* Appends an element to a copy of the array and returns the copy.
|
||||
*
|
||||
* @param array The original array, or null to represent an empty array.
|
||||
* @param element The element to add.
|
||||
* @return A new array that contains all of the elements of the original array
|
||||
* with the specified element added at the end.
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public static <T> T[] appendElement(Class<T> kind, T[] array, T element) {
|
||||
final T[] result;
|
||||
final int end;
|
||||
if (array != null) {
|
||||
end = array.length;
|
||||
result = (T[]) Array.newInstance(kind, end + 1);
|
||||
System.arraycopy(array, 0, result, 0, end);
|
||||
} else {
|
||||
end = 0;
|
||||
result = (T[]) Array.newInstance(kind, 1);
|
||||
}
|
||||
result[end] = element;
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes an element from a copy of the array and returns the copy.
|
||||
* If the element is not present, then the original array is returned unmodified.
|
||||
*
|
||||
* @param array The original array, or null to represent an empty array.
|
||||
* @param element The element to remove.
|
||||
* @return A new array that contains all of the elements of the original array
|
||||
* except the first copy of the specified element removed. If the specified element
|
||||
* was not present, then returns the original array. Returns null if the result
|
||||
* would be an empty array.
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public static <T> T[] removeElement(Class<T> kind, T[] array, T element) {
|
||||
if (array != null) {
|
||||
final int length = array.length;
|
||||
for (int i = 0; i < length; i++) {
|
||||
if (array[i] == element) {
|
||||
if (length == 1) {
|
||||
return null;
|
||||
}
|
||||
T[] result = (T[]) Array.newInstance(kind, length - 1);
|
||||
System.arraycopy(array, 0, result, 0, i);
|
||||
System.arraycopy(array, i + 1, result, i, length - i - 1);
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
public static int[] appendInt(int[] cur, int val) {
|
||||
if (cur == null) {
|
||||
return new int[]{val};
|
||||
}
|
||||
final int N = cur.length;
|
||||
for (int i = 0; i < N; i++) {
|
||||
if (cur[i] == val) {
|
||||
return cur;
|
||||
}
|
||||
}
|
||||
int[] ret = new int[N + 1];
|
||||
System.arraycopy(cur, 0, ret, 0, N);
|
||||
ret[N] = val;
|
||||
return ret;
|
||||
}
|
||||
|
||||
public static int[] removeInt(int[] cur, int val) {
|
||||
if (cur == null) {
|
||||
return null;
|
||||
}
|
||||
final int N = cur.length;
|
||||
for (int i = 0; i < N; i++) {
|
||||
if (cur[i] == val) {
|
||||
int[] ret = new int[N - 1];
|
||||
if (i > 0) {
|
||||
System.arraycopy(cur, 0, ret, 0, i);
|
||||
}
|
||||
if (i < (N - 1)) {
|
||||
System.arraycopy(cur, i + 1, ret, i, N - i - 1);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
return cur;
|
||||
}
|
||||
}
|
||||
@@ -1,62 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2007 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.internal.util;
|
||||
|
||||
import java.util.Arrays;
|
||||
|
||||
/**
|
||||
* Object utility methods.
|
||||
*/
|
||||
public class Objects {
|
||||
|
||||
/**
|
||||
* Determines whether two possibly-null objects are equal. Returns:
|
||||
* <p/>
|
||||
* <ul>
|
||||
* <li>{@code true} if {@code a} and {@code b} are both null.
|
||||
* <li>{@code true} if {@code a} and {@code b} are both non-null and they are
|
||||
* equal according to {@link Object#equals(Object)}.
|
||||
* <li>{@code false} in all other situations.
|
||||
* </ul>
|
||||
* <p/>
|
||||
* <p>This assumes that any non-null objects passed to this function conform
|
||||
* to the {@code equals()} contract.
|
||||
*/
|
||||
public static boolean equal(Object a, Object b) {
|
||||
return a == b || (a != null && a.equals(b));
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates a hash code for multiple values. The hash code is generated by
|
||||
* calling {@link Arrays#hashCode(Object[])}.
|
||||
* <p/>
|
||||
* <p>This is useful for implementing {@link Object#hashCode()}. For example,
|
||||
* in an object that has three properties, {@code x}, {@code y}, and
|
||||
* {@code z}, one could write:
|
||||
* <pre>
|
||||
* public int hashCode() {
|
||||
* return Objects.hashCode(getX(), getY(), getZ());
|
||||
* }</pre>
|
||||
*
|
||||
* <b>Warning</b>: When a single object is supplied, the returned hash code
|
||||
* does not equal the hash code of that object.
|
||||
*/
|
||||
public static int hashCode(Object... objects) {
|
||||
return Arrays.hashCode(objects);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,69 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2011 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.internal.util;
|
||||
|
||||
/**
|
||||
* Simple static methods to be called at the start of your own methods to verify
|
||||
* correct arguments and state.
|
||||
*/
|
||||
public class Preconditions {
|
||||
|
||||
/**
|
||||
* Ensures that an object reference passed as a parameter to the calling
|
||||
* method is not null.
|
||||
*
|
||||
* @param reference an object reference
|
||||
* @return the non-null reference that was validated
|
||||
* @throws NullPointerException if {@code reference} is null
|
||||
*/
|
||||
public static <T> T checkNotNull(T reference) {
|
||||
if (reference == null) {
|
||||
throw new NullPointerException();
|
||||
}
|
||||
return reference;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensures that an object reference passed as a parameter to the calling
|
||||
* method is not null.
|
||||
*
|
||||
* @param reference an object reference
|
||||
* @param errorMessage the exception message to use if the check fails; will
|
||||
* be converted to a string using {@link String#valueOf(Object)}
|
||||
* @return the non-null reference that was validated
|
||||
* @throws NullPointerException if {@code reference} is null
|
||||
*/
|
||||
public static <T> T checkNotNull(T reference, Object errorMessage) {
|
||||
if (reference == null) {
|
||||
throw new NullPointerException(String.valueOf(errorMessage));
|
||||
}
|
||||
return reference;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensures the truth of an expression involving the state of the calling
|
||||
* instance, but not involving any parameters to the calling method.
|
||||
*
|
||||
* @param expression a boolean expression
|
||||
* @throws IllegalStateException if {@code expression} is false
|
||||
*/
|
||||
public static void checkState(boolean expression) {
|
||||
if (!expression) {
|
||||
throw new IllegalStateException();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,760 +0,0 @@
|
||||
/*
|
||||
* Copyright 2014 Jacob Klinker
|
||||
*
|
||||
* 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.mms.dom.smil;
|
||||
|
||||
import com.android.mms.logs.LogTag;
|
||||
import com.klinker.android.logger.Log;
|
||||
import org.w3c.dom.NodeList;
|
||||
import org.w3c.dom.events.DocumentEvent;
|
||||
import org.w3c.dom.events.Event;
|
||||
import org.w3c.dom.events.EventTarget;
|
||||
import org.w3c.dom.smil.ElementParallelTimeContainer;
|
||||
import org.w3c.dom.smil.ElementSequentialTimeContainer;
|
||||
import org.w3c.dom.smil.ElementTime;
|
||||
import org.w3c.dom.smil.Time;
|
||||
import org.w3c.dom.smil.TimeList;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.Comparator;
|
||||
import java.util.HashSet;
|
||||
|
||||
/**
|
||||
* The SmilPlayer is responsible for playing, stopping, pausing and resuming a SMIL tree.
|
||||
* <li>It creates a whole timeline before playing.</li>
|
||||
* <li>The player runs in a different thread which intends not to block the main thread.</li>
|
||||
*/
|
||||
public class SmilPlayer implements Runnable {
|
||||
private static final String TAG = LogTag.TAG;
|
||||
private static final boolean DEBUG = false;
|
||||
private static final boolean LOCAL_LOGV = false;
|
||||
private static final int TIMESLICE = 200;
|
||||
|
||||
private static enum SmilPlayerState {
|
||||
INITIALIZED,
|
||||
PLAYING,
|
||||
PLAYED,
|
||||
PAUSED,
|
||||
STOPPED,
|
||||
}
|
||||
|
||||
private static enum SmilPlayerAction {
|
||||
NO_ACTIVE_ACTION,
|
||||
RELOAD,
|
||||
STOP,
|
||||
PAUSE,
|
||||
START,
|
||||
NEXT,
|
||||
PREV
|
||||
}
|
||||
|
||||
public static final String MEDIA_TIME_UPDATED_EVENT = "mediaTimeUpdated";
|
||||
|
||||
private static final Comparator<TimelineEntry> sTimelineEntryComparator =
|
||||
new Comparator<TimelineEntry>() {
|
||||
public int compare(TimelineEntry o1, TimelineEntry o2) {
|
||||
return Double.compare(o1.getOffsetTime(), o2.getOffsetTime());
|
||||
}
|
||||
};
|
||||
|
||||
private static SmilPlayer sPlayer;
|
||||
|
||||
private long mCurrentTime;
|
||||
private int mCurrentElement;
|
||||
private int mCurrentSlide;
|
||||
private ArrayList<TimelineEntry> mAllEntries;
|
||||
private ElementTime mRoot;
|
||||
private Thread mPlayerThread;
|
||||
private SmilPlayerState mState = SmilPlayerState.INITIALIZED;
|
||||
private SmilPlayerAction mAction = SmilPlayerAction.NO_ACTIVE_ACTION;
|
||||
private ArrayList<ElementTime> mActiveElements;
|
||||
private Event mMediaTimeUpdatedEvent;
|
||||
|
||||
private static ArrayList<TimelineEntry> getParTimeline(
|
||||
ElementParallelTimeContainer par, double offset, double maxOffset) {
|
||||
ArrayList<TimelineEntry> timeline = new ArrayList<TimelineEntry>();
|
||||
|
||||
// Set my begin at first
|
||||
TimeList myBeginList = par.getBegin();
|
||||
/*
|
||||
* Begin list only contain 1 begin time which has been resolved.
|
||||
* @see com.android.mms.dom.smil.ElementParallelTimeContainerImpl#getBegin()
|
||||
*/
|
||||
Time begin = myBeginList.item(0);
|
||||
double beginOffset = begin.getResolvedOffset() + offset;
|
||||
if (beginOffset > maxOffset) {
|
||||
// This element can't be started.
|
||||
return timeline;
|
||||
}
|
||||
TimelineEntry myBegin = new TimelineEntry(beginOffset, par, TimelineEntry.ACTION_BEGIN);
|
||||
timeline.add(myBegin);
|
||||
|
||||
TimeList myEndList = par.getEnd();
|
||||
/*
|
||||
* End list only contain 1 end time which has been resolved.
|
||||
* @see com.android.mms.dom.smil.ElementParallelTimeContainerImpl#getEnd()
|
||||
*/
|
||||
Time end = myEndList.item(0);
|
||||
double endOffset = end.getResolvedOffset() + offset;
|
||||
if (endOffset > maxOffset) {
|
||||
endOffset = maxOffset;
|
||||
}
|
||||
TimelineEntry myEnd = new TimelineEntry(endOffset, par, TimelineEntry.ACTION_END);
|
||||
|
||||
maxOffset = endOffset;
|
||||
|
||||
NodeList children = par.getTimeChildren();
|
||||
for (int i = 0; i < children.getLength(); ++i) {
|
||||
ElementTime child = (ElementTime) children.item(i);
|
||||
ArrayList<TimelineEntry> childTimeline = getTimeline(child, offset, maxOffset);
|
||||
timeline.addAll(childTimeline);
|
||||
}
|
||||
|
||||
Collections.sort(timeline, sTimelineEntryComparator);
|
||||
|
||||
// Add end-event to timeline for all active children
|
||||
NodeList activeChildrenAtEnd = par.getActiveChildrenAt(
|
||||
(float) (endOffset - offset) * 1000);
|
||||
for (int i = 0; i < activeChildrenAtEnd.getLength(); ++i) {
|
||||
timeline.add(new TimelineEntry(endOffset,
|
||||
(ElementTime) activeChildrenAtEnd.item(i),
|
||||
TimelineEntry.ACTION_END));
|
||||
}
|
||||
|
||||
// Set my end at last
|
||||
timeline.add(myEnd);
|
||||
|
||||
return timeline;
|
||||
}
|
||||
|
||||
private static ArrayList<TimelineEntry> getSeqTimeline(
|
||||
ElementSequentialTimeContainer seq, double offset, double maxOffset) {
|
||||
ArrayList<TimelineEntry> timeline = new ArrayList<TimelineEntry>();
|
||||
double orgOffset = offset;
|
||||
|
||||
// Set my begin at first
|
||||
TimeList myBeginList = seq.getBegin();
|
||||
/*
|
||||
* Begin list only contain 1 begin time which has been resolved.
|
||||
* @see com.android.mms.dom.smil.ElementSequentialTimeContainerImpl#getBegin()
|
||||
*/
|
||||
Time begin = myBeginList.item(0);
|
||||
double beginOffset = begin.getResolvedOffset() + offset;
|
||||
if (beginOffset > maxOffset) {
|
||||
// This element can't be started.
|
||||
return timeline;
|
||||
}
|
||||
TimelineEntry myBegin = new TimelineEntry(beginOffset, seq, TimelineEntry.ACTION_BEGIN);
|
||||
timeline.add(myBegin);
|
||||
|
||||
TimeList myEndList = seq.getEnd();
|
||||
/*
|
||||
* End list only contain 1 end time which has been resolved.
|
||||
* @see com.android.mms.dom.smil.ElementSequentialTimeContainerImpl#getEnd()
|
||||
*/
|
||||
Time end = myEndList.item(0);
|
||||
double endOffset = end.getResolvedOffset() + offset;
|
||||
if (endOffset > maxOffset) {
|
||||
endOffset = maxOffset;
|
||||
}
|
||||
TimelineEntry myEnd = new TimelineEntry(endOffset, seq, TimelineEntry.ACTION_END);
|
||||
|
||||
maxOffset = endOffset;
|
||||
|
||||
// Get children's timelines
|
||||
NodeList children = seq.getTimeChildren();
|
||||
for (int i = 0; i < children.getLength(); ++i) {
|
||||
ElementTime child = (ElementTime) children.item(i);
|
||||
ArrayList<TimelineEntry> childTimeline = getTimeline(child, offset, maxOffset);
|
||||
timeline.addAll(childTimeline);
|
||||
|
||||
// Since the child timeline has been sorted, the offset of the last one is the biggest.
|
||||
offset = childTimeline.get(childTimeline.size() - 1).getOffsetTime();
|
||||
}
|
||||
|
||||
// Add end-event to timeline for all active children
|
||||
NodeList activeChildrenAtEnd = seq.getActiveChildrenAt(
|
||||
(float) (endOffset - orgOffset));
|
||||
for (int i = 0; i < activeChildrenAtEnd.getLength(); ++i) {
|
||||
timeline.add(new TimelineEntry(endOffset,
|
||||
(ElementTime) activeChildrenAtEnd.item(i),
|
||||
TimelineEntry.ACTION_END));
|
||||
}
|
||||
|
||||
// Set my end at last
|
||||
timeline.add(myEnd);
|
||||
|
||||
return timeline;
|
||||
}
|
||||
|
||||
private static ArrayList<TimelineEntry> getTimeline(ElementTime element,
|
||||
double offset, double maxOffset) {
|
||||
if (element instanceof ElementParallelTimeContainer) {
|
||||
return getParTimeline((ElementParallelTimeContainer) element, offset, maxOffset);
|
||||
} else if (element instanceof ElementSequentialTimeContainer) {
|
||||
return getSeqTimeline((ElementSequentialTimeContainer) element, offset, maxOffset);
|
||||
} else {
|
||||
// Not ElementTimeContainer here
|
||||
ArrayList<TimelineEntry> timeline = new ArrayList<TimelineEntry>();
|
||||
|
||||
TimeList beginList = element.getBegin();
|
||||
for (int i = 0; i < beginList.getLength(); ++i) {
|
||||
Time begin = beginList.item(i);
|
||||
if (begin.getResolved()) {
|
||||
double beginOffset = begin.getResolvedOffset() + offset;
|
||||
if (beginOffset <= maxOffset) {
|
||||
TimelineEntry entry = new TimelineEntry(beginOffset,
|
||||
element, TimelineEntry.ACTION_BEGIN);
|
||||
timeline.add(entry);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TimeList endList = element.getEnd();
|
||||
for (int i = 0; i < endList.getLength(); ++i) {
|
||||
Time end = endList.item(i);
|
||||
if (end.getResolved()) {
|
||||
double endOffset = end.getResolvedOffset() + offset;
|
||||
if (endOffset <= maxOffset) {
|
||||
TimelineEntry entry = new TimelineEntry(endOffset,
|
||||
element, TimelineEntry.ACTION_END);
|
||||
timeline.add(entry);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Collections.sort(timeline, sTimelineEntryComparator);
|
||||
|
||||
return timeline;
|
||||
}
|
||||
}
|
||||
|
||||
private SmilPlayer() {
|
||||
// Private constructor
|
||||
}
|
||||
|
||||
public static SmilPlayer getPlayer() {
|
||||
if (sPlayer == null) {
|
||||
sPlayer = new SmilPlayer();
|
||||
}
|
||||
return sPlayer;
|
||||
}
|
||||
|
||||
public synchronized boolean isPlayingState() {
|
||||
return mState == SmilPlayerState.PLAYING;
|
||||
}
|
||||
|
||||
public synchronized boolean isPlayedState() {
|
||||
return mState == SmilPlayerState.PLAYED;
|
||||
}
|
||||
|
||||
public synchronized boolean isPausedState() {
|
||||
return mState == SmilPlayerState.PAUSED;
|
||||
}
|
||||
|
||||
public synchronized boolean isStoppedState() {
|
||||
return mState == SmilPlayerState.STOPPED;
|
||||
}
|
||||
|
||||
private synchronized boolean isPauseAction() {
|
||||
return mAction == SmilPlayerAction.PAUSE;
|
||||
}
|
||||
|
||||
private synchronized boolean isStartAction() {
|
||||
return mAction == SmilPlayerAction.START;
|
||||
}
|
||||
|
||||
private synchronized boolean isStopAction() {
|
||||
return mAction == SmilPlayerAction.STOP;
|
||||
}
|
||||
|
||||
private synchronized boolean isReloadAction() {
|
||||
return mAction == SmilPlayerAction.RELOAD;
|
||||
}
|
||||
|
||||
private synchronized boolean isNextAction() {
|
||||
return mAction == SmilPlayerAction.NEXT;
|
||||
}
|
||||
|
||||
private synchronized boolean isPrevAction() {
|
||||
return mAction == SmilPlayerAction.PREV;
|
||||
}
|
||||
|
||||
public synchronized void init(ElementTime root) {
|
||||
mRoot = root;
|
||||
mAllEntries = getTimeline(mRoot, 0, Long.MAX_VALUE);
|
||||
mMediaTimeUpdatedEvent = ((DocumentEvent) mRoot).createEvent("Event");
|
||||
mMediaTimeUpdatedEvent.initEvent(MEDIA_TIME_UPDATED_EVENT, false, false);
|
||||
mActiveElements = new ArrayList<ElementTime>();
|
||||
}
|
||||
|
||||
public synchronized void play() {
|
||||
if (!isPlayingState()) {
|
||||
mCurrentTime = 0;
|
||||
mCurrentElement = 0;
|
||||
mCurrentSlide = 0;
|
||||
mPlayerThread = new Thread(this, "SmilPlayer thread");
|
||||
mState = SmilPlayerState.PLAYING;
|
||||
mPlayerThread.start();
|
||||
} else {
|
||||
Log.w(TAG, "Error State: Playback is playing!");
|
||||
}
|
||||
}
|
||||
|
||||
public synchronized void pause() {
|
||||
if (isPlayingState()) {
|
||||
mAction = SmilPlayerAction.PAUSE;
|
||||
notifyAll();
|
||||
} else {
|
||||
Log.w(TAG, "Error State: Playback is not playing!");
|
||||
}
|
||||
}
|
||||
|
||||
public synchronized void start() {
|
||||
if (isPausedState()) {
|
||||
resumeActiveElements();
|
||||
mAction = SmilPlayerAction.START;
|
||||
notifyAll();
|
||||
} else if (isPlayedState()) {
|
||||
play();
|
||||
} else {
|
||||
Log.w(TAG, "Error State: Playback can not be started!");
|
||||
}
|
||||
}
|
||||
|
||||
public synchronized void stop() {
|
||||
if (isPlayingState() || isPausedState()) {
|
||||
mAction = SmilPlayerAction.STOP;
|
||||
notifyAll();
|
||||
} else if (isPlayedState()) {
|
||||
actionStop();
|
||||
}
|
||||
}
|
||||
|
||||
public synchronized void stopWhenReload() {
|
||||
endActiveElements();
|
||||
}
|
||||
|
||||
public synchronized void reload() {
|
||||
if (isPlayingState() || isPausedState()) {
|
||||
mAction = SmilPlayerAction.RELOAD;
|
||||
notifyAll();
|
||||
} else if (isPlayedState()) {
|
||||
actionReload();
|
||||
}
|
||||
}
|
||||
|
||||
public synchronized void next() {
|
||||
if (isPlayingState() || isPausedState()) {
|
||||
mAction = SmilPlayerAction.NEXT;
|
||||
notifyAll();
|
||||
}
|
||||
}
|
||||
|
||||
public synchronized void prev() {
|
||||
if (isPlayingState() || isPausedState()) {
|
||||
mAction = SmilPlayerAction.PREV;
|
||||
notifyAll();
|
||||
}
|
||||
}
|
||||
|
||||
private synchronized boolean isBeginOfSlide(TimelineEntry entry) {
|
||||
return (TimelineEntry.ACTION_BEGIN == entry.getAction())
|
||||
&& (entry.getElement() instanceof SmilParElementImpl);
|
||||
}
|
||||
|
||||
private synchronized void reloadActiveSlide() {
|
||||
mActiveElements.clear();
|
||||
beginSmilDocument();
|
||||
|
||||
for (int i = mCurrentSlide; i < mCurrentElement; i++) {
|
||||
TimelineEntry entry = mAllEntries.get(i);
|
||||
actionEntry(entry);
|
||||
}
|
||||
seekActiveMedia();
|
||||
}
|
||||
|
||||
private synchronized void beginSmilDocument() {
|
||||
TimelineEntry entry = mAllEntries.get(0);
|
||||
actionEntry(entry);
|
||||
}
|
||||
|
||||
private synchronized double getOffsetTime(ElementTime element) {
|
||||
for (int i = mCurrentSlide; i < mCurrentElement; i++) {
|
||||
TimelineEntry entry = mAllEntries.get(i);
|
||||
if (element.equals(entry.getElement())) {
|
||||
return entry.getOffsetTime() * 1000; // in ms
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
private synchronized void seekActiveMedia() {
|
||||
for (int i = mActiveElements.size() - 1; i >= 0; i--) {
|
||||
ElementTime element = mActiveElements.get(i);
|
||||
if (element instanceof SmilParElementImpl) {
|
||||
return;
|
||||
}
|
||||
double offset = getOffsetTime(element);
|
||||
if ((offset >= 0) && (offset <= mCurrentTime)) {
|
||||
if (LOCAL_LOGV) {
|
||||
Log.v(TAG, "[SEEK] " + " at " + mCurrentTime
|
||||
+ " " + element);
|
||||
}
|
||||
element.seekElement( (float) (mCurrentTime - offset) );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private synchronized void waitForEntry(long interval)
|
||||
throws InterruptedException {
|
||||
if (LOCAL_LOGV) {
|
||||
Log.v(TAG, "Waiting for " + interval + "ms.");
|
||||
}
|
||||
|
||||
long overhead = 0;
|
||||
|
||||
while (interval > 0) {
|
||||
long startAt = System.currentTimeMillis();
|
||||
long sleep = Math.min(interval, TIMESLICE);
|
||||
if (overhead < sleep) {
|
||||
wait(sleep - overhead);
|
||||
mCurrentTime += sleep;
|
||||
} else {
|
||||
sleep = 0;
|
||||
mCurrentTime += overhead;
|
||||
}
|
||||
|
||||
if (isStopAction() || isReloadAction() || isPauseAction() || isNextAction() ||
|
||||
isPrevAction()) {
|
||||
return;
|
||||
}
|
||||
|
||||
((EventTarget) mRoot).dispatchEvent(mMediaTimeUpdatedEvent);
|
||||
|
||||
interval -= TIMESLICE;
|
||||
overhead = System.currentTimeMillis() - startAt - sleep;
|
||||
}
|
||||
}
|
||||
|
||||
public synchronized int getDuration() {
|
||||
if ((mAllEntries != null) && !mAllEntries.isEmpty()) {
|
||||
return (int) mAllEntries.get(mAllEntries.size() - 1).mOffsetTime * 1000;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
public synchronized int getCurrentPosition() {
|
||||
return (int) mCurrentTime;
|
||||
}
|
||||
|
||||
private synchronized void endActiveElements() {
|
||||
for (int i = mActiveElements.size() - 1; i >= 0; i--) {
|
||||
ElementTime element = mActiveElements.get(i);
|
||||
if (LOCAL_LOGV) {
|
||||
Log.v(TAG, "[STOP] " + " at " + mCurrentTime
|
||||
+ " " + element);
|
||||
}
|
||||
element.endElement();
|
||||
}
|
||||
}
|
||||
|
||||
private synchronized void pauseActiveElements() {
|
||||
for (int i = mActiveElements.size() - 1; i >= 0; i--) {
|
||||
ElementTime element = mActiveElements.get(i);
|
||||
if (LOCAL_LOGV) {
|
||||
Log.v(TAG, "[PAUSE] " + " at " + mCurrentTime
|
||||
+ " " + element);
|
||||
}
|
||||
element.pauseElement();
|
||||
}
|
||||
}
|
||||
|
||||
private synchronized void resumeActiveElements() {
|
||||
int size = mActiveElements.size();
|
||||
for (int i = 0; i < size; i++) {
|
||||
ElementTime element = mActiveElements.get(i);
|
||||
if (LOCAL_LOGV) {
|
||||
Log.v(TAG, "[RESUME] " + " at " + mCurrentTime
|
||||
+ " " + element);
|
||||
}
|
||||
element.resumeElement();
|
||||
}
|
||||
}
|
||||
|
||||
private synchronized void waitForWakeUp() {
|
||||
try {
|
||||
while ( !(isStartAction() || isStopAction() || isReloadAction() ||
|
||||
isNextAction() || isPrevAction()) ) {
|
||||
wait(TIMESLICE);
|
||||
}
|
||||
if (isStartAction()) {
|
||||
mAction = SmilPlayerAction.NO_ACTIVE_ACTION;
|
||||
mState = SmilPlayerState.PLAYING;
|
||||
}
|
||||
} catch (InterruptedException e) {
|
||||
Log.e(TAG, "Unexpected InterruptedException.", e);
|
||||
}
|
||||
}
|
||||
|
||||
private synchronized void actionEntry(TimelineEntry entry) {
|
||||
switch (entry.getAction()) {
|
||||
case TimelineEntry.ACTION_BEGIN:
|
||||
if (LOCAL_LOGV) {
|
||||
Log.v(TAG, "[START] " + " at " + mCurrentTime + " "
|
||||
+ entry.getElement());
|
||||
}
|
||||
entry.getElement().beginElement();
|
||||
mActiveElements.add(entry.getElement());
|
||||
break;
|
||||
case TimelineEntry.ACTION_END:
|
||||
if (LOCAL_LOGV) {
|
||||
Log.v(TAG, "[STOP] " + " at " + mCurrentTime + " "
|
||||
+ entry.getElement());
|
||||
}
|
||||
entry.getElement().endElement();
|
||||
mActiveElements.remove(entry.getElement());
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private synchronized TimelineEntry reloadCurrentEntry() {
|
||||
// Check if the position is less than size of all entries
|
||||
if (mCurrentElement < mAllEntries.size()) {
|
||||
return mAllEntries.get(mCurrentElement);
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
private void stopCurrentSlide() {
|
||||
HashSet<TimelineEntry> skippedEntries = new HashSet<TimelineEntry>();
|
||||
int totalEntries = mAllEntries.size();
|
||||
for (int i = mCurrentElement; i < totalEntries; i++) {
|
||||
// Stop any started entries, and skip the not started entries until
|
||||
// meeting the end of slide
|
||||
TimelineEntry entry = mAllEntries.get(i);
|
||||
int action = entry.getAction();
|
||||
if (entry.getElement() instanceof SmilParElementImpl &&
|
||||
action == TimelineEntry.ACTION_END) {
|
||||
actionEntry(entry);
|
||||
mCurrentElement = i;
|
||||
break;
|
||||
} else if (action == TimelineEntry.ACTION_END && !skippedEntries.contains(entry)) {
|
||||
actionEntry(entry);
|
||||
} else if (action == TimelineEntry.ACTION_BEGIN) {
|
||||
skippedEntries.add(entry);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private TimelineEntry loadNextSlide() {
|
||||
TimelineEntry entry;
|
||||
int totalEntries = mAllEntries.size();
|
||||
for (int i = mCurrentElement; i < totalEntries; i++) {
|
||||
entry = mAllEntries.get(i);
|
||||
if (isBeginOfSlide(entry)) {
|
||||
mCurrentElement = i;
|
||||
mCurrentSlide = i;
|
||||
mCurrentTime = (long)(entry.getOffsetTime() * 1000);
|
||||
return entry;
|
||||
}
|
||||
}
|
||||
// No slide, finish play back
|
||||
mCurrentElement++;
|
||||
entry = null;
|
||||
if (mCurrentElement < totalEntries) {
|
||||
entry = mAllEntries.get(mCurrentElement);
|
||||
mCurrentTime = (long)(entry.getOffsetTime() * 1000);
|
||||
}
|
||||
return entry;
|
||||
}
|
||||
|
||||
private TimelineEntry loadPrevSlide() {
|
||||
int skippedSlides = 1;
|
||||
int latestBeginEntryIndex = -1;
|
||||
for (int i = mCurrentSlide; i >= 0; i--) {
|
||||
TimelineEntry entry = mAllEntries.get(i);
|
||||
if (isBeginOfSlide(entry)) {
|
||||
latestBeginEntryIndex = i;
|
||||
if (0 == skippedSlides-- ) {
|
||||
mCurrentElement = i;
|
||||
mCurrentSlide = i;
|
||||
mCurrentTime = (long)(entry.getOffsetTime() * 1000);
|
||||
return entry;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (latestBeginEntryIndex != -1) {
|
||||
mCurrentElement = latestBeginEntryIndex;
|
||||
mCurrentSlide = latestBeginEntryIndex;
|
||||
return mAllEntries.get(mCurrentElement);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private synchronized TimelineEntry actionNext() {
|
||||
stopCurrentSlide();
|
||||
return loadNextSlide();
|
||||
}
|
||||
|
||||
private synchronized TimelineEntry actionPrev() {
|
||||
stopCurrentSlide();
|
||||
return loadPrevSlide();
|
||||
}
|
||||
|
||||
private synchronized void actionPause() {
|
||||
pauseActiveElements();
|
||||
mState = SmilPlayerState.PAUSED;
|
||||
mAction = SmilPlayerAction.NO_ACTIVE_ACTION;
|
||||
}
|
||||
|
||||
private synchronized void actionStop() {
|
||||
endActiveElements();
|
||||
mCurrentTime = 0;
|
||||
mCurrentElement = 0;
|
||||
mCurrentSlide = 0;
|
||||
mState = SmilPlayerState.STOPPED;
|
||||
mAction = SmilPlayerAction.NO_ACTIVE_ACTION;
|
||||
}
|
||||
|
||||
private synchronized void actionReload() {
|
||||
reloadActiveSlide();
|
||||
mAction = SmilPlayerAction.NO_ACTIVE_ACTION;
|
||||
}
|
||||
|
||||
public void run() {
|
||||
if (isStoppedState()) {
|
||||
return;
|
||||
}
|
||||
if (LOCAL_LOGV) {
|
||||
dumpAllEntries();
|
||||
}
|
||||
// Play the Element by following the timeline
|
||||
int size = mAllEntries.size();
|
||||
for (mCurrentElement = 0; mCurrentElement < size; mCurrentElement++) {
|
||||
TimelineEntry entry = mAllEntries.get(mCurrentElement);
|
||||
if (isBeginOfSlide(entry)) {
|
||||
mCurrentSlide = mCurrentElement;
|
||||
}
|
||||
long offset = (long) (entry.getOffsetTime() * 1000); // in ms.
|
||||
while (offset > mCurrentTime) {
|
||||
try {
|
||||
waitForEntry(offset - mCurrentTime);
|
||||
} catch (InterruptedException e) {
|
||||
Log.e(TAG, "Unexpected InterruptedException.", e);
|
||||
}
|
||||
|
||||
while (isPauseAction() || isStopAction() || isReloadAction() || isNextAction() ||
|
||||
isPrevAction()) {
|
||||
if (isPauseAction()) {
|
||||
actionPause();
|
||||
waitForWakeUp();
|
||||
}
|
||||
|
||||
if (isStopAction()) {
|
||||
actionStop();
|
||||
return;
|
||||
}
|
||||
|
||||
if (isReloadAction()) {
|
||||
actionReload();
|
||||
entry = reloadCurrentEntry();
|
||||
if (entry == null)
|
||||
return;
|
||||
if (isPausedState()) {
|
||||
mAction = SmilPlayerAction.PAUSE;
|
||||
}
|
||||
}
|
||||
|
||||
if (isNextAction()) {
|
||||
TimelineEntry nextEntry = actionNext();
|
||||
if (nextEntry != null) {
|
||||
entry = nextEntry;
|
||||
}
|
||||
if (mState == SmilPlayerState.PAUSED) {
|
||||
mAction = SmilPlayerAction.PAUSE;
|
||||
actionEntry(entry);
|
||||
} else {
|
||||
mAction = SmilPlayerAction.NO_ACTIVE_ACTION;
|
||||
}
|
||||
offset = mCurrentTime;
|
||||
}
|
||||
|
||||
if (isPrevAction()) {
|
||||
TimelineEntry prevEntry = actionPrev();
|
||||
if (prevEntry != null) {
|
||||
entry = prevEntry;
|
||||
}
|
||||
if (mState == SmilPlayerState.PAUSED) {
|
||||
mAction = SmilPlayerAction.PAUSE;
|
||||
actionEntry(entry);
|
||||
} else {
|
||||
mAction = SmilPlayerAction.NO_ACTIVE_ACTION;
|
||||
}
|
||||
offset = mCurrentTime;
|
||||
}
|
||||
}
|
||||
}
|
||||
mCurrentTime = offset;
|
||||
actionEntry(entry);
|
||||
}
|
||||
|
||||
mState = SmilPlayerState.PLAYED;
|
||||
}
|
||||
|
||||
private static final class TimelineEntry {
|
||||
final static int ACTION_BEGIN = 0;
|
||||
final static int ACTION_END = 1;
|
||||
|
||||
private final double mOffsetTime;
|
||||
private final ElementTime mElement;
|
||||
private final int mAction;
|
||||
|
||||
public TimelineEntry(double offsetTime, ElementTime element, int action) {
|
||||
mOffsetTime = offsetTime;
|
||||
mElement = element;
|
||||
mAction = action;
|
||||
}
|
||||
|
||||
public double getOffsetTime() {
|
||||
return mOffsetTime;
|
||||
}
|
||||
|
||||
public ElementTime getElement() {
|
||||
return mElement;
|
||||
}
|
||||
|
||||
public int getAction() {
|
||||
return mAction;
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
return "Type = " + mElement + " offset = " + getOffsetTime() + " action = " + getAction();
|
||||
}
|
||||
}
|
||||
|
||||
private void dumpAllEntries() {
|
||||
if (LOCAL_LOGV) {
|
||||
for (TimelineEntry entry : mAllEntries) {
|
||||
Log.v(TAG, "[Entry] "+ entry);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,92 +0,0 @@
|
||||
/*
|
||||
* Copyright 2014 Jacob Klinker
|
||||
*
|
||||
* 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.mms.dom.smil.parser;
|
||||
|
||||
import com.android.mms.dom.smil.SmilDocumentImpl;
|
||||
import com.android.mms.logs.LogTag;
|
||||
import com.klinker.android.logger.Log;
|
||||
import org.w3c.dom.Element;
|
||||
import org.w3c.dom.Node;
|
||||
import org.w3c.dom.smil.SMILDocument;
|
||||
import org.xml.sax.Attributes;
|
||||
import org.xml.sax.helpers.DefaultHandler;
|
||||
|
||||
public class SmilContentHandler extends DefaultHandler {
|
||||
private static final String TAG = LogTag.TAG;
|
||||
private static final boolean DEBUG = false;
|
||||
private static final boolean LOCAL_LOGV = false;
|
||||
|
||||
private SMILDocument mSmilDocument;
|
||||
private Node mCurrentNode;
|
||||
|
||||
/**
|
||||
* Resets this handler.
|
||||
*
|
||||
*/
|
||||
public void reset() {
|
||||
mSmilDocument = new SmilDocumentImpl();
|
||||
mCurrentNode = mSmilDocument;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the SMILDocument.
|
||||
* @return The SMILDocument instance
|
||||
*/
|
||||
public SMILDocument getSmilDocument() {
|
||||
return mSmilDocument;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void startElement(String uri, String localName, String qName, Attributes attributes) {
|
||||
if (LOCAL_LOGV) {
|
||||
Log.v(TAG, "SmilContentHandler.startElement. Creating element " + localName);
|
||||
}
|
||||
Element element = mSmilDocument.createElement(localName);
|
||||
if (attributes != null) {
|
||||
for (int i = 0; i < attributes.getLength(); i++) {
|
||||
if (LOCAL_LOGV) {
|
||||
Log.v(TAG, "Attribute " + i +
|
||||
" lname = " + attributes.getLocalName(i) +
|
||||
" value = " + attributes.getValue(i));
|
||||
}
|
||||
element.setAttribute(attributes.getLocalName(i),
|
||||
attributes.getValue(i));
|
||||
}
|
||||
}
|
||||
if (LOCAL_LOGV) {
|
||||
Log.v(TAG, "Appending " + localName + " to " + mCurrentNode.getNodeName());
|
||||
}
|
||||
mCurrentNode.appendChild(element);
|
||||
|
||||
mCurrentNode = element;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void endElement(String uri, String localName, String qName) {
|
||||
if (LOCAL_LOGV) {
|
||||
Log.v(TAG, "SmilContentHandler.endElement. localName " + localName);
|
||||
}
|
||||
mCurrentNode = mCurrentNode.getParentNode();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void characters(char[] ch, int start, int length) {
|
||||
if (LOCAL_LOGV) {
|
||||
Log.v(TAG, "SmilContentHandler.characters. ch = " + new String(ch, start, length));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,74 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2007 Esmertec AG.
|
||||
* Copyright (C) 2007 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.mms.dom.smil.parser;
|
||||
|
||||
import com.google.android.mms.MmsException;
|
||||
import org.w3c.dom.smil.SMILDocument;
|
||||
import org.xml.sax.InputSource;
|
||||
import org.xml.sax.SAXException;
|
||||
import org.xml.sax.XMLReader;
|
||||
import org.xml.sax.helpers.XMLReaderFactory;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
|
||||
public class SmilXmlParser {
|
||||
private XMLReader mXmlReader;
|
||||
private SmilContentHandler mContentHandler;
|
||||
|
||||
public SmilXmlParser() throws MmsException {
|
||||
//FIXME: Now we don't have the SAXParser wrapped inside,
|
||||
// use the Driver class temporarily.
|
||||
System.setProperty("org.xml.sax.driver", "org.xmlpull.v1.sax2.Driver");
|
||||
|
||||
try {
|
||||
mXmlReader = XMLReaderFactory.createXMLReader();
|
||||
mContentHandler = new SmilContentHandler();
|
||||
mXmlReader.setContentHandler(mContentHandler);
|
||||
} catch (SAXException e) {
|
||||
throw new MmsException(e);
|
||||
}
|
||||
}
|
||||
|
||||
public SMILDocument parse(InputStream in) throws IOException, SAXException {
|
||||
mContentHandler.reset();
|
||||
|
||||
mXmlReader.parse(new InputSource(in));
|
||||
|
||||
SMILDocument doc = mContentHandler.getSmilDocument();
|
||||
validateDocument(doc);
|
||||
|
||||
return doc;
|
||||
}
|
||||
|
||||
private void validateDocument(SMILDocument doc) {
|
||||
/*
|
||||
* Calling getBody() will create "smil", "head", and "body" elements if they
|
||||
* are not present. It will also initialize the SequentialTimeElementContainer
|
||||
* member of SMILDocument, which could not be set on creation of the document.
|
||||
* @see com.android.mms.dom.smil.SmilDocumentImpl#getBody()
|
||||
*/
|
||||
doc.getBody();
|
||||
|
||||
/*
|
||||
* Calling getLayout() will create "layout" element if it is not present.
|
||||
* @see com.android.mms.dom.smil.SmilDocumentImpl#getLayout()
|
||||
*/
|
||||
doc.getLayout();
|
||||
}
|
||||
}
|
||||
@@ -16,69 +16,8 @@
|
||||
|
||||
package com.android.mms.logs;
|
||||
|
||||
import com.klinker.android.logger.Log;
|
||||
|
||||
public class LogTag {
|
||||
public static final String TAG = "Mms";
|
||||
|
||||
public static final String TRANSACTION = TAG;
|
||||
public static final String APP = TAG;
|
||||
public static final String THREAD_CACHE = TAG;
|
||||
public static final String THUMBNAIL_CACHE = TAG;
|
||||
public static final String PDU_CACHE = TAG;
|
||||
public static final String WIDGET = TAG;
|
||||
public static final String CONTACT = TAG;
|
||||
|
||||
/**
|
||||
* Log tag for enabling/disabling StrictMode violation log.
|
||||
* To enable: adb shell setprop log.tag.Mms:strictmode DEBUG
|
||||
*/
|
||||
public static final String STRICT_MODE_TAG = TAG;
|
||||
public static final boolean VERBOSE = false;
|
||||
public static final boolean SEVERE_WARNING = true; // Leave this true
|
||||
private static final boolean SHOW_SEVERE_WARNING_DIALOG = false; // Set to false before ship
|
||||
public static final boolean DEBUG_SEND = false; // Set to false before ship
|
||||
public static final boolean DEBUG_DUMP = false; // Set to false before ship
|
||||
public static final boolean ALLOW_DUMP_IN_LOGS = false; // Set to false before ship
|
||||
|
||||
private static String prettyArray(String[] array) {
|
||||
if (array.length == 0) {
|
||||
return "[]";
|
||||
}
|
||||
|
||||
StringBuilder sb = new StringBuilder("[");
|
||||
int len = array.length-1;
|
||||
for (int i = 0; i < len; i++) {
|
||||
sb.append(array[i]);
|
||||
sb.append(", ");
|
||||
}
|
||||
sb.append(array[len]);
|
||||
sb.append("]");
|
||||
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
private static String logFormat(String format, Object... args) {
|
||||
for (int i = 0; i < args.length; i++) {
|
||||
if (args[i] instanceof String[]) {
|
||||
args[i] = prettyArray((String[])args[i]);
|
||||
}
|
||||
}
|
||||
String s = String.format(format, args);
|
||||
s = "[" + Thread.currentThread().getId() + "] " + s;
|
||||
return s;
|
||||
}
|
||||
|
||||
public static void debug(String format, Object... args) {
|
||||
Log.d(TAG, logFormat(format, args));
|
||||
}
|
||||
|
||||
public static void warn(String format, Object... args) {
|
||||
Log.w(TAG, logFormat(format, args));
|
||||
}
|
||||
|
||||
public static void error(String format, Object... args) {
|
||||
Log.e(TAG, logFormat(format, args));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -1,99 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2015 Jacob Klinker
|
||||
*
|
||||
* 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.mms.service_alt;
|
||||
|
||||
import android.content.ContentValues;
|
||||
import android.content.Context;
|
||||
import android.net.Uri;
|
||||
import android.provider.Telephony;
|
||||
import android.util.Log;
|
||||
import com.android.mms.transaction.NotificationTransaction;
|
||||
import com.google.android.mms.MmsException;
|
||||
import com.google.android.mms.pdu_alt.PduParser;
|
||||
import com.google.android.mms.pdu_alt.PduPersister;
|
||||
import com.google.android.mms.pdu_alt.RetrieveConf;
|
||||
import com.google.android.mms.util_alt.SqliteWrapper;
|
||||
|
||||
public class MmsRequestManager implements MmsRequest.RequestManager {
|
||||
|
||||
private static final String TAG = "MmsRequestManager";
|
||||
|
||||
private Context context;
|
||||
private byte[] pduData;
|
||||
|
||||
public MmsRequestManager(Context context) {
|
||||
this(context, null);
|
||||
}
|
||||
|
||||
public MmsRequestManager(Context context, byte[] pduData) {
|
||||
this.context = context;
|
||||
this.pduData = pduData;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addSimRequest(MmsRequest request) {
|
||||
// Do nothing, this will not be invoked ever.
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean getAutoPersistingPref() {
|
||||
return NotificationTransaction.allowAutoDownload(context);
|
||||
}
|
||||
|
||||
@Override
|
||||
public byte[] readPduFromContentUri(Uri contentUri, int maxSize) {
|
||||
return pduData;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean writePduToContentUri(Uri contentUri, byte[] response) {
|
||||
if (response == null || response.length < 1) {
|
||||
Log.e(TAG, "empty response");
|
||||
return false;
|
||||
}
|
||||
try {
|
||||
// Parse M-Retrieve.conf
|
||||
RetrieveConf retrieveConf = (RetrieveConf) new PduParser(response).parse();
|
||||
if (null == retrieveConf) {
|
||||
throw new MmsException("Invalid M-Retrieve.conf PDU.");
|
||||
}
|
||||
|
||||
Uri msgUri;
|
||||
|
||||
// Store M-Retrieve.conf into Inbox
|
||||
PduPersister persister = PduPersister.getPduPersister(context);
|
||||
msgUri = persister.persist(retrieveConf, Telephony.Mms.Inbox.CONTENT_URI, true,
|
||||
true, null);
|
||||
|
||||
// Use local time instead of PDU time
|
||||
ContentValues values = new ContentValues(2);
|
||||
values.put(Telephony.Mms.DATE, System.currentTimeMillis() / 1000L);
|
||||
values.put(Telephony.Mms.MESSAGE_SIZE, response.length);
|
||||
SqliteWrapper.update(context, context.getContentResolver(),
|
||||
msgUri, values, null, null);
|
||||
|
||||
// Send ACK to the Proxy-Relay to indicate we have fetched the
|
||||
// MM successfully.
|
||||
// Don't mark the transaction as failed if we failed to send it.
|
||||
// sendAcknowledgeInd(retrieveConf);
|
||||
} catch (Throwable t) {
|
||||
com.klinker.android.logger.Log.e(TAG, "error", t);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -1,33 +0,0 @@
|
||||
/*
|
||||
* Copyright 2014 Jacob Klinker
|
||||
*
|
||||
* 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.mms.transaction;
|
||||
|
||||
import com.google.android.mms.MmsException;
|
||||
|
||||
public interface MessageSender {
|
||||
public static final String RECIPIENTS_SEPARATOR = ";";
|
||||
|
||||
/**
|
||||
* Send the message through MMS or SMS protocol.
|
||||
* @param token The token to identify the sending progress.
|
||||
*
|
||||
* @return True if the message was sent through MMS or false if it was
|
||||
* sent through SMS.
|
||||
* @throws com.google.android.mms.MmsException Error occurred while sending the message.
|
||||
*/
|
||||
boolean sendMessage(long token) throws MmsException;
|
||||
}
|
||||
@@ -29,6 +29,7 @@ class ScheduledActivity : QkThemedActivity(), ScheduledView {
|
||||
showBackButton(true)
|
||||
viewModel.bindView(this)
|
||||
|
||||
dialog.title = getString(R.string.scheduled_options_title)
|
||||
dialog.adapter.setData(R.array.scheduled_options)
|
||||
|
||||
messageAdapter.emptyView = empty
|
||||
|
||||
+14
-1
@@ -1,8 +1,11 @@
|
||||
package com.moez.QKSMS.feature.scheduled
|
||||
|
||||
import android.net.Uri
|
||||
import android.telephony.PhoneNumberUtils
|
||||
import android.view.LayoutInflater
|
||||
import android.view.ViewGroup
|
||||
import androidx.core.view.isVisible
|
||||
import androidx.recyclerview.widget.RecyclerView
|
||||
import com.moez.QKSMS.R
|
||||
import com.moez.QKSMS.common.base.QkRealmAdapter
|
||||
import com.moez.QKSMS.common.base.QkViewHolder
|
||||
@@ -25,11 +28,17 @@ class ScheduledMessageAdapter @Inject constructor(
|
||||
|
||||
private val contacts by lazy { contactRepo.getContacts() }
|
||||
private val contactMap: HashMap<String, Contact> = hashMapOf()
|
||||
private val imagesViewPool = RecyclerView.RecycledViewPool()
|
||||
|
||||
val clicks: Subject<Long> = PublishSubject.create()
|
||||
|
||||
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): QkViewHolder {
|
||||
return QkViewHolder(LayoutInflater.from(parent.context).inflate(R.layout.scheduled_message_list_item, parent, false))
|
||||
val view = LayoutInflater.from(parent.context).inflate(R.layout.scheduled_message_list_item, parent, false)
|
||||
|
||||
view.attachments.adapter = ScheduledMessageAttachmentAdapter()
|
||||
view.attachments.setRecycledViewPool(imagesViewPool)
|
||||
|
||||
return QkViewHolder(view)
|
||||
}
|
||||
|
||||
override fun onBindViewHolder(holder: QkViewHolder, position: Int) {
|
||||
@@ -55,6 +64,10 @@ class ScheduledMessageAdapter @Inject constructor(
|
||||
|
||||
view.date.text = dateFormatter.getScheduledTimestamp(message.date)
|
||||
view.body.text = message.body
|
||||
|
||||
val adapter = view.attachments.adapter as ScheduledMessageAttachmentAdapter
|
||||
adapter.data = message.attachments.map(Uri::parse)
|
||||
view.attachments.isVisible = message.attachments.isNotEmpty()
|
||||
}
|
||||
|
||||
}
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
package com.moez.QKSMS.feature.scheduled
|
||||
|
||||
import android.net.Uri
|
||||
import android.view.LayoutInflater
|
||||
import android.view.ViewGroup
|
||||
import com.moez.QKSMS.R
|
||||
import com.moez.QKSMS.common.base.QkAdapter
|
||||
import com.moez.QKSMS.common.base.QkViewHolder
|
||||
import com.moez.QKSMS.common.util.GlideApp
|
||||
import kotlinx.android.synthetic.main.attachment_list_item.view.*
|
||||
import javax.inject.Inject
|
||||
|
||||
class ScheduledMessageAttachmentAdapter @Inject constructor() : QkAdapter<Uri>() {
|
||||
|
||||
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): QkViewHolder {
|
||||
val view = LayoutInflater.from(parent.context).inflate(R.layout.scheduled_message_image_list_item, parent, false)
|
||||
view.thumbnail.clipToOutline = true
|
||||
|
||||
return QkViewHolder(view)
|
||||
}
|
||||
|
||||
override fun onBindViewHolder(holder: QkViewHolder, position: Int) {
|
||||
val attachment = getItem(position)
|
||||
val view = holder.itemView
|
||||
|
||||
GlideApp.with(view).load(attachment).into(view.thumbnail)
|
||||
}
|
||||
|
||||
}
|
||||
@@ -137,8 +137,6 @@ class SettingsViewModel @Inject constructor(
|
||||
|
||||
R.id.notifications -> navigator.showNotificationSettings()
|
||||
|
||||
R.id.blocked -> navigator.showBlockedConversations()
|
||||
|
||||
R.id.delayed -> view.showDelayDurationDialog()
|
||||
|
||||
R.id.delivery -> prefs.delivery.set(!prefs.delivery.get())
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
<?xml version="1.0" encoding="utf-8"?><!--
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
~ Copyright (C) 2017 Moez Bhatti <moez.bhatti@gmail.com>
|
||||
~
|
||||
~ This file is part of QKSMS.
|
||||
@@ -51,7 +52,7 @@
|
||||
app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager"
|
||||
app:layout_constraintBottom_toBottomOf="parent"
|
||||
app:layout_constraintTop_toBottomOf="@id/toolbar"
|
||||
tools:listitem="@layout/blocked_list_item" />
|
||||
tools:listitem="@layout/scheduled_message_list_item" />
|
||||
|
||||
<View
|
||||
android:layout_width="match_parent"
|
||||
|
||||
@@ -0,0 +1,36 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
~ Copyright (C) 2017 Moez Bhatti <moez.bhatti@gmail.com>
|
||||
~
|
||||
~ This file is part of QKSMS.
|
||||
~
|
||||
~ QKSMS is free software: you can redistribute it and/or modify
|
||||
~ it under the terms of the GNU General Public License as published by
|
||||
~ the Free Software Foundation, either version 3 of the License, or
|
||||
~ (at your option) any later version.
|
||||
~
|
||||
~ QKSMS is distributed in the hope that it will be useful,
|
||||
~ but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
~ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
~ GNU General Public License for more details.
|
||||
~
|
||||
~ You should have received a copy of the GNU General Public License
|
||||
~ along with QKSMS. If not, see <http://www.gnu.org/licenses/>.
|
||||
-->
|
||||
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
xmlns:tools="http://schemas.android.com/tools"
|
||||
android:layout_width="48dp"
|
||||
android:layout_height="48dp"
|
||||
android:layout_marginEnd="8dp">
|
||||
|
||||
<ImageView
|
||||
android:id="@+id/thumbnail"
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="match_parent"
|
||||
android:adjustViewBounds="true"
|
||||
android:background="@drawable/rounded_rectangle_4dp"
|
||||
android:backgroundTint="?android:attr/divider"
|
||||
android:scaleType="centerCrop"
|
||||
tools:src="@tools:sample/backgrounds/scenic" />
|
||||
|
||||
</FrameLayout>
|
||||
@@ -25,10 +25,7 @@
|
||||
android:background="?attr/selectableItemBackground"
|
||||
android:gravity="center_vertical"
|
||||
android:orientation="horizontal"
|
||||
android:paddingBottom="12dp"
|
||||
android:paddingEnd="16dp"
|
||||
android:paddingStart="16dp"
|
||||
android:paddingTop="12dp">
|
||||
android:padding="16dp">
|
||||
|
||||
<com.moez.QKSMS.common.widget.GroupAvatarView
|
||||
android:id="@+id/avatars"
|
||||
@@ -70,10 +67,24 @@
|
||||
android:layout_width="0dp"
|
||||
android:layout_height="wrap_content"
|
||||
android:layout_marginTop="2dp"
|
||||
app:layout_constraintBottom_toBottomOf="parent"
|
||||
app:layout_constraintEnd_toEndOf="parent"
|
||||
app:layout_constraintStart_toStartOf="@id/recipients"
|
||||
app:layout_constraintTop_toBottomOf="@id/date"
|
||||
tools:text="@tools:sample/lorem/random" />
|
||||
|
||||
<androidx.recyclerview.widget.RecyclerView
|
||||
android:id="@+id/attachments"
|
||||
android:layout_width="0dp"
|
||||
android:layout_height="wrap_content"
|
||||
android:layout_marginTop="8dp"
|
||||
android:nestedScrollingEnabled="false"
|
||||
android:orientation="horizontal"
|
||||
app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager"
|
||||
app:layout_constraintBottom_toBottomOf="parent"
|
||||
app:layout_constraintEnd_toEndOf="parent"
|
||||
app:layout_constraintHorizontal_bias="0"
|
||||
app:layout_constraintStart_toStartOf="@id/recipients"
|
||||
app:layout_constraintTop_toBottomOf="@id/body"
|
||||
tools:listitem="@layout/scheduled_message_image_list_item" />
|
||||
|
||||
</androidx.constraintlayout.widget.ConstraintLayout>
|
||||
@@ -139,13 +139,6 @@
|
||||
app:title="@string/settings_auto_emoji_title"
|
||||
app:widget="@layout/settings_switch_widget" />
|
||||
|
||||
<com.moez.QKSMS.common.widget.PreferenceView
|
||||
android:id="@+id/blocked"
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content"
|
||||
app:icon="@drawable/ic_block_black_24dp"
|
||||
app:title="@string/settings_blocking_title" />
|
||||
|
||||
<com.moez.QKSMS.common.widget.PreferenceView
|
||||
android:id="@+id/delayed"
|
||||
android:layout_width="match_parent"
|
||||
|
||||
@@ -137,6 +137,7 @@
|
||||
|
||||
<string name="scheduled_title">Scheduled</string>
|
||||
<string name="scheduled_empty_text">Your scheduled messages will appear here</string>
|
||||
<string name="scheduled_options_title">Scheduled message</string>
|
||||
<string-array name="scheduled_options">
|
||||
<item>Send now</item>
|
||||
<item>Delete</item>
|
||||
|
||||
Reference in New Issue
Block a user