import android.annotation.Nullable;
import android.annotation.SystemApi;
import android.os.Bundle;
+import android.os.SystemClock;
import android.telecom.Connection.VideoProvider;
import android.util.ArraySet;
private int mConnectionProperties;
private String mDisconnectMessage;
private long mConnectTimeMillis = CONNECT_TIME_NOT_SPECIFIED;
+ private long mConnectElapsedTimeMillis = CONNECT_TIME_NOT_SPECIFIED;
private StatusHints mStatusHints;
private Bundle mExtras;
private Set<String> mPreviousExtraKeys;
}
/**
- * Sets the connection start time of the {@code Conference}.
+ * Sets the connection start time of the {@code Conference}. Should be specified in wall-clock
+ * time returned by {@link System#currentTimeMillis()}.
*
* @param connectionTimeMillis The connection time, in milliseconds.
*/
}
/**
+ * Sets the elapsed time since system boot when the {@link Conference} was connected.
+ * This is used to determine the duration of the {@link Conference}.
+ * <p>
+ * When setting the connection elapsed time, you should always set the connection time via
+ * {@link #setConnectionTime(long)}.
+ *
+ * @param connectionElapsedTime The connection time, as measured by
+ * {@link SystemClock#elapsedRealtime()}.
+ * @hide
+ */
+ public final void setConnectionElapsedTime(long connectionElapsedTime) {
+ mConnectElapsedTimeMillis = connectionElapsedTime;
+ }
+
+ /**
* @hide
* @deprecated Use {@link #getConnectionTime}.
*/
}
/**
+ * Retrieves the connection start time of the {@link Conference}, if specified. A value of
+ * {@link #CONNECT_TIME_NOT_SPECIFIED} indicates that Telecom should determine the start time
+ * of the conference.
+ *
+ * This is based on the value of {@link SystemClock#elapsedRealtime()} to ensure that it is not
+ * impacted by wall clock changes (user initiated, network initiated, time zone change, etc).
+ *
+ * @return The elapsed time at which the {@link Conference} was connected.
+ * @hide
+ */
+ public final long getConnectElapsedTime() {
+ return mConnectElapsedTimeMillis;
+ }
+
+ /**
* Inform this Conference that the state of its audio output has been changed externally.
*
* @param state The new audio state.
import com.android.internal.telecom.IVideoCallback;
import com.android.internal.telecom.IVideoProvider;
-import android.annotation.IntDef;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.SystemApi;
import android.os.Message;
import android.os.ParcelFileDescriptor;
import android.os.RemoteException;
+import android.os.SystemClock;
import android.util.ArraySet;
import android.view.Surface;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
private VideoProvider mVideoProvider;
private boolean mAudioModeIsVoip;
private long mConnectTimeMillis = Conference.CONNECT_TIME_NOT_SPECIFIED;
+ private long mConnectElapsedTimeMillis = Conference.CONNECT_TIME_NOT_SPECIFIED;
private StatusHints mStatusHints;
private int mVideoState;
private DisconnectCause mDisconnectCause;
}
/**
+ * Retrieves the connection start time of the {@link Connection}, if specified. A value of
+ * {@link Conference#CONNECT_TIME_NOT_SPECIFIED} indicates that Telecom should determine the
+ * start time of the conference.
+ *
+ * Based on the value of {@link SystemClock#elapsedRealtime()}, which ensures that wall-clock
+ * changes do not impact the call duration.
+ *
+ * @return The time at which the {@link Connection} was connected.
+ *
+ * @hide
+ */
+ public final long getConnectElapsedTimeMillis() {
+ return mConnectElapsedTimeMillis;
+ }
+
+ /**
* @return The status hints for this connection.
*/
public final StatusHints getStatusHints() {
* Sets the time at which a call became active on this Connection. This is set only
* when a conference call becomes active on this connection.
*
- * @param connectionTimeMillis The connection time, in milliseconds.
+ * @param connectTimeMillis The connection time, in milliseconds. Should be set using a value
+ * obtained from {@link System#currentTimeMillis()}.
*
* @hide
*/
}
/**
+ * Sets the time at which a call became active on this Connection. This is set only
+ * when a conference call becomes active on this connection.
+ *
+ * @param connectElapsedTimeMillis The connection time, in milliseconds. Stored in the format
+ * {@link SystemClock#elapsedRealtime()}.
+ *
+ * @hide
+ */
+ public final void setConnectElapsedTimeMillis(long connectElapsedTimeMillis) {
+ mConnectElapsedTimeMillis = connectElapsedTimeMillis;
+ }
+
+ /**
* Sets the label and icon status to display in the in-call UI.
*
* @param statusHints The status label and icon to set.
connection.isRingbackRequested(),
connection.getAudioModeIsVoip(),
connection.getConnectTimeMillis(),
+ connection.getConnectElapsedTimeMillis(),
connection.getStatusHints(),
connection.getDisconnectCause(),
createIdList(connection.getConferenceables()),
null : conference.getVideoProvider().getInterface(),
conference.getVideoState(),
conference.getConnectTimeMillis(),
+ conference.getConnectElapsedTime(),
conference.getStatusHints(),
conference.getExtras());
connection.isRingbackRequested(),
connection.getAudioModeIsVoip(),
connection.getConnectTimeMillis(),
+ connection.getConnectElapsedTimeMillis(),
connection.getStatusHints(),
connection.getDisconnectCause(),
emptyList,
private final int mVideoState;
private StatusHints mStatusHints;
private Bundle mExtras;
+ private long mConnectElapsedTimeMillis = Conference.CONNECT_TIME_NOT_SPECIFIED;
public ParcelableConference(
PhoneAccountHandle phoneAccount,
IVideoProvider videoProvider,
int videoState,
long connectTimeMillis,
+ long connectElapsedTimeMillis,
StatusHints statusHints,
Bundle extras) {
mPhoneAccount = phoneAccount;
mConnectionCapabilities = connectionCapabilities;
mConnectionProperties = connectionProperties;
mConnectionIds = connectionIds;
- mConnectTimeMillis = Conference.CONNECT_TIME_NOT_SPECIFIED;
mVideoProvider = videoProvider;
mVideoState = videoState;
mConnectTimeMillis = connectTimeMillis;
mStatusHints = statusHints;
mExtras = extras;
+ mConnectElapsedTimeMillis = connectElapsedTimeMillis;
}
@Override
public long getConnectTimeMillis() {
return mConnectTimeMillis;
}
+
+ public long getConnectElapsedTimeMillis() {
+ return mConnectElapsedTimeMillis;
+ }
+
public IVideoProvider getVideoProvider() {
return mVideoProvider;
}
StatusHints statusHints = source.readParcelable(classLoader);
Bundle extras = source.readBundle(classLoader);
int properties = source.readInt();
+ long connectElapsedTimeMillis = source.readLong();
return new ParcelableConference(phoneAccount, state, capabilities, properties,
- connectionIds, videoCallProvider, videoState, connectTimeMillis, statusHints,
- extras);
+ connectionIds, videoCallProvider, videoState, connectTimeMillis,
+ connectElapsedTimeMillis, statusHints, extras);
}
@Override
destination.writeParcelable(mStatusHints, 0);
destination.writeBundle(mExtras);
destination.writeInt(mConnectionProperties);
+ destination.writeLong(mConnectElapsedTimeMillis);
}
}
private final boolean mRingbackRequested;
private final boolean mIsVoipAudioMode;
private final long mConnectTimeMillis;
+ private final long mConnectElapsedTimeMillis;
private final StatusHints mStatusHints;
private final DisconnectCause mDisconnectCause;
private final List<String> mConferenceableConnectionIds;
boolean ringbackRequested,
boolean isVoipAudioMode,
long connectTimeMillis,
+ long connectElapsedTimeMillis,
StatusHints statusHints,
DisconnectCause disconnectCause,
List<String> conferenceableConnectionIds,
this(phoneAccount, state, capabilities, properties, supportedAudioRoutes, address,
addressPresentation, callerDisplayName, callerDisplayNamePresentation,
videoProvider, videoState, ringbackRequested, isVoipAudioMode, connectTimeMillis,
- statusHints, disconnectCause, conferenceableConnectionIds, extras);
+ connectElapsedTimeMillis, statusHints, disconnectCause, conferenceableConnectionIds,
+ extras);
mParentCallId = parentCallId;
}
boolean ringbackRequested,
boolean isVoipAudioMode,
long connectTimeMillis,
+ long connectElapsedTimeMillis,
StatusHints statusHints,
DisconnectCause disconnectCause,
List<String> conferenceableConnectionIds,
mRingbackRequested = ringbackRequested;
mIsVoipAudioMode = isVoipAudioMode;
mConnectTimeMillis = connectTimeMillis;
+ mConnectElapsedTimeMillis = connectElapsedTimeMillis;
mStatusHints = statusHints;
mDisconnectCause = disconnectCause;
mConferenceableConnectionIds = conferenceableConnectionIds;
return mConnectTimeMillis;
}
+ public long getConnectElapsedTimeMillis() {
+ return mConnectElapsedTimeMillis;
+ }
+
public final StatusHints getStatusHints() {
return mStatusHints;
}
int properties = source.readInt();
int supportedAudioRoutes = source.readInt();
String parentCallId = source.readString();
+ long connectElapsedTimeMillis = source.readLong();
return new ParcelableConnection(
phoneAccount,
ringbackRequested,
audioModeIsVoip,
connectTimeMillis,
+ connectElapsedTimeMillis,
statusHints,
disconnectCause,
conferenceableConnectionIds,
destination.writeInt(mConnectionProperties);
destination.writeInt(mSupportedAudioRoutes);
destination.writeString(mParentCallId);
+ destination.writeLong(mConnectElapsedTimeMillis);
}
}