202 lines
7.8 KiB
Java
202 lines
7.8 KiB
Java
/*
|
|
* Copyright (C) 2016 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.ims.internal;
|
|
|
|
import android.telecom.VideoProfile;
|
|
import android.telephony.ims.ImsVideoCallProvider;
|
|
import android.util.ArraySet;
|
|
import android.util.Log;
|
|
|
|
import java.util.Collection;
|
|
import java.util.Set;
|
|
import java.util.stream.Collectors;
|
|
|
|
/**
|
|
* Used by an {@link ImsVideoCallProviderWrapper} to track requests to pause video from various
|
|
* sources.
|
|
*
|
|
* Requests to pause the video stream using the {@link VideoProfile#STATE_PAUSED} bit can come
|
|
* from both the {@link android.telecom.InCallService}, as well as via the
|
|
* {@link ImsVideoCallProviderWrapper#pauseVideo(int, int)} and
|
|
* {@link ImsVideoCallProviderWrapper#resumeVideo(int, int)} methods. As a result, multiple sources
|
|
* can potentially pause or resume the video stream.
|
|
*
|
|
* This class is responsible for tracking any active requests to pause the video.
|
|
*/
|
|
public class VideoPauseTracker {
|
|
/** The pause or resume request originated from an InCallService. */
|
|
public static final int SOURCE_INCALL = 1;
|
|
|
|
/**
|
|
* The pause or resume request originated from a change to the data enabled state from the
|
|
* {@code ImsPhoneCallTracker#onDataEnabledChanged(boolean, int)} callback. This happens when
|
|
* the user reaches their data limit or enables and disables data.
|
|
*/
|
|
public static final int SOURCE_DATA_ENABLED = 2;
|
|
|
|
private static final String SOURCE_INCALL_STR = "INCALL";
|
|
private static final String SOURCE_DATA_ENABLED_STR = "DATA_ENABLED";
|
|
|
|
private static final String LOG_TAG = VideoPauseTracker.class.getSimpleName();
|
|
|
|
/**
|
|
* Tracks the current sources of pause requests.
|
|
*/
|
|
private Set<Integer> mPauseRequests = new ArraySet<Integer>(2);
|
|
|
|
/**
|
|
* Lock for the {@link #mPauseRequests} {@link ArraySet}.
|
|
*/
|
|
private Object mPauseRequestsLock = new Object();
|
|
|
|
/**
|
|
* Tracks a request to pause the video for a source (see {@link #SOURCE_DATA_ENABLED},
|
|
* {@link #SOURCE_INCALL}) and determines whether a pause request should be issued to the
|
|
* video provider.
|
|
*
|
|
* We want to issue a pause request to the provider when we receive the first request
|
|
* to pause via any source and we're not already paused.
|
|
*
|
|
* @param source The source of the pause request.
|
|
* @return {@code true} if a pause should be issued to the
|
|
* {@link ImsVideoCallProvider}, {@code false} otherwise.
|
|
*/
|
|
public boolean shouldPauseVideoFor(int source) {
|
|
synchronized (mPauseRequestsLock) {
|
|
boolean wasPaused = isPaused();
|
|
mPauseRequests.add(source);
|
|
|
|
if (!wasPaused) {
|
|
Log.i(LOG_TAG, String.format(
|
|
"shouldPauseVideoFor: source=%s, pendingRequests=%s - should pause",
|
|
sourceToString(source), sourcesToString(mPauseRequests)));
|
|
// There were previously no pause requests, but there is one now, so pause.
|
|
return true;
|
|
} else {
|
|
Log.i(LOG_TAG, String.format(
|
|
"shouldPauseVideoFor: source=%s, pendingRequests=%s - already paused",
|
|
sourceToString(source), sourcesToString(mPauseRequests)));
|
|
// There were already pause requests, so no need to re-pause.
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tracks a request to resume the video for a source (see {@link #SOURCE_DATA_ENABLED},
|
|
* {@link #SOURCE_INCALL}) and determines whether a resume request should be issued to the
|
|
* video provider.
|
|
*
|
|
* We want to issue a resume request to the provider when we have issued a corresponding
|
|
* resume for each previously issued pause.
|
|
*
|
|
* @param source The source of the resume request.
|
|
* @return {@code true} if a resume should be issued to the
|
|
* {@link ImsVideoCallProvider}, {@code false} otherwise.
|
|
*/
|
|
public boolean shouldResumeVideoFor(int source) {
|
|
synchronized (mPauseRequestsLock) {
|
|
boolean wasPaused = isPaused();
|
|
mPauseRequests.remove(source);
|
|
boolean isPaused = isPaused();
|
|
|
|
if (wasPaused && !isPaused) {
|
|
Log.i(LOG_TAG, String.format(
|
|
"shouldResumeVideoFor: source=%s, pendingRequests=%s - should resume",
|
|
sourceToString(source), sourcesToString(mPauseRequests)));
|
|
// This was the last pause request, so resume video.
|
|
return true;
|
|
} else if (wasPaused && isPaused) {
|
|
Log.i(LOG_TAG, String.format(
|
|
"shouldResumeVideoFor: source=%s, pendingRequests=%s - stay paused",
|
|
sourceToString(source), sourcesToString(mPauseRequests)));
|
|
// There are still pending pause requests, so don't resume.
|
|
return false;
|
|
} else {
|
|
Log.i(LOG_TAG, String.format(
|
|
"shouldResumeVideoFor: source=%s, pendingRequests=%s - not paused",
|
|
sourceToString(source), sourcesToString(mPauseRequests)));
|
|
// Although there are no pending pause requests, it is possible that we cleared the
|
|
// pause tracker because the video state reported we're un-paused. In this case it
|
|
// is benign to just allow the resume request to be sent since it'll have no effect.
|
|
// Re-writing it to squelch the resume would end up causing it to be a pause
|
|
// request, which is bad.
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return {@code true} if the video should be paused, {@code false} otherwise.
|
|
*/
|
|
public boolean isPaused() {
|
|
synchronized (mPauseRequestsLock) {
|
|
return !mPauseRequests.isEmpty();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param source the source of the pause.
|
|
* @return {@code true} if the specified source initiated a pause request and the video is
|
|
* currently paused, {@code false} otherwise.
|
|
*/
|
|
public boolean wasVideoPausedFromSource(int source) {
|
|
synchronized (mPauseRequestsLock) {
|
|
return mPauseRequests.contains(source);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Clears pending pause requests for the tracker.
|
|
*/
|
|
public void clearPauseRequests() {
|
|
synchronized (mPauseRequestsLock) {
|
|
mPauseRequests.clear();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a string equivalent of a {@code SOURCE_*} constant.
|
|
*
|
|
* @param source A {@code SOURCE_*} constant.
|
|
* @return String equivalent of the source.
|
|
*/
|
|
private String sourceToString(int source) {
|
|
switch (source) {
|
|
case SOURCE_DATA_ENABLED:
|
|
return SOURCE_DATA_ENABLED_STR;
|
|
case SOURCE_INCALL:
|
|
return SOURCE_INCALL_STR;
|
|
}
|
|
return "unknown";
|
|
}
|
|
|
|
/**
|
|
* Returns a comma separated list of sources.
|
|
*
|
|
* @param sources The sources.
|
|
* @return Comma separated list of sources.
|
|
*/
|
|
private String sourcesToString(Collection<Integer> sources) {
|
|
synchronized (mPauseRequestsLock) {
|
|
return sources.stream()
|
|
.map(source -> sourceToString(source))
|
|
.collect(Collectors.joining(", "));
|
|
}
|
|
}
|
|
}
|