T checkNotNull(T reference, String errorMessage) {
13 | if (reference == null) {
14 | throw new NullPointerException(errorMessage);
15 | }
16 | return reference;
17 | }
18 |
19 | static void checkArgument(boolean expression) {
20 | if (!expression) {
21 | throw new IllegalArgumentException();
22 | }
23 | }
24 |
25 | static void checkArgument(boolean expression, String errorMessage) {
26 | if (!expression) {
27 | throw new IllegalArgumentException(errorMessage);
28 | }
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/ProxyCache.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache;
2 |
3 | import android.os.Handler;
4 | import android.os.Looper;
5 | import android.util.Log;
6 |
7 | import java.util.concurrent.atomic.AtomicInteger;
8 |
9 | import static com.danikula.videocache.Preconditions.checkNotNull;
10 | import static com.danikula.videocache.ProxyCacheUtils.LOG_TAG;
11 |
12 | /**
13 | * Proxy for {@link Source} with caching support ({@link Cache}).
14 | *
15 | * Can be used only for sources with persistent data (that doesn't change with time).
16 | * Method {@link #read(byte[], long, int)} will be blocked while fetching data from source.
17 | * Useful for streaming something with caching e.g. streaming video/audio etc.
18 | *
19 | * @author Alexey Danilov (danikula@gmail.com).
20 | */
21 | public class ProxyCache {
22 |
23 | private static final int MAX_READ_SOURCE_ATTEMPTS = 1;
24 |
25 | private final Source source;
26 | private final Cache cache;
27 | private final Object wc;
28 | private final Handler handler;
29 | private volatile Thread sourceReaderThread;
30 | private volatile boolean stopped;
31 | private final AtomicInteger readSourceErrorsCount;
32 | private CacheListener cacheListener;
33 | private final boolean logEnabled;
34 |
35 | public ProxyCache(Source source, Cache cache, boolean logEnabled) {
36 | this.source = checkNotNull(source);
37 | this.cache = checkNotNull(cache);
38 | this.logEnabled = logEnabled;
39 | this.wc = new Object();
40 | this.handler = new Handler(Looper.getMainLooper());
41 | this.readSourceErrorsCount = new AtomicInteger();
42 | }
43 |
44 | public ProxyCache(Source source, Cache cache) {
45 | this(source, cache, false);
46 | }
47 |
48 | public void setCacheListener(CacheListener cacheListener) {
49 | this.cacheListener = cacheListener;
50 | }
51 |
52 | public int read(byte[] buffer, long offset, int length) throws ProxyCacheException {
53 | ProxyCacheUtils.assertBuffer(buffer, offset, length);
54 |
55 | while (!cache.isCompleted() && cache.available() < (offset + length) && !stopped) {
56 | readSourceAsync();
57 | waitForSourceData();
58 | checkIsCacheValid();
59 | checkReadSourceErrorsCount();
60 | }
61 | int read = cache.read(buffer, offset, length);
62 | if (isLogEnabled()) {
63 | Log.d(LOG_TAG, "Read data[" + read + " bytes] from cache with offset " + offset + ": " + ProxyCacheUtils.preview(buffer, read));
64 | }
65 | return read;
66 | }
67 |
68 | private void checkIsCacheValid() throws ProxyCacheException {
69 | int sourceAvailable = source.available();
70 | if (sourceAvailable > 0 && cache.available() > sourceAvailable) {
71 | throw new ProxyCacheException("Unexpected cache: cache [" + cache.available() + " bytes] > source[" + sourceAvailable + " bytes]");
72 | }
73 | }
74 |
75 | private void checkReadSourceErrorsCount() throws ProxyCacheException {
76 | int errorsCount = readSourceErrorsCount.get();
77 | if (errorsCount >= MAX_READ_SOURCE_ATTEMPTS) {
78 | readSourceErrorsCount.set(0);
79 | throw new ProxyCacheException("Error reading source " + errorsCount + " times");
80 | }
81 | }
82 |
83 | public void shutdown() {
84 | try {
85 | stopped = true;
86 | if (sourceReaderThread != null) {
87 | sourceReaderThread.interrupt();
88 | }
89 | cache.close();
90 | } catch (ProxyCacheException e) {
91 | onError(e);
92 | }
93 | }
94 |
95 | private void readSourceAsync() throws ProxyCacheException {
96 |
97 | boolean readingInProgress = sourceReaderThread != null && sourceReaderThread.getState() != Thread.State.TERMINATED;
98 | if (!stopped && !cache.isCompleted() && !readingInProgress) {
99 | sourceReaderThread = new Thread(new SourceReaderRunnable(), "Source reader for ProxyCache");
100 | sourceReaderThread.start();
101 | }
102 | }
103 |
104 | private void waitForSourceData() throws ProxyCacheException {
105 | synchronized (wc) {
106 | try {
107 | wc.wait(1000);
108 | } catch (InterruptedException e) {
109 | throw new ProxyCacheException("Waiting source data is interrupted!", e);
110 | }
111 | }
112 | }
113 |
114 | private void notifyNewCacheDataAvailable(final int cachePercentage) {
115 | handler.post(new Runnable() {
116 | @Override
117 | public void run() {
118 | if (cacheListener != null) {
119 | cacheListener.onCacheDataAvailable(cachePercentage);
120 | }
121 | }
122 | });
123 |
124 | synchronized (wc) {
125 | wc.notifyAll();
126 | }
127 | }
128 |
129 | private void readSource() {
130 | int cachePercentage = 0;
131 | try {
132 | int offset = cache.available();
133 | source.open(offset);
134 | byte[] buffer = new byte[ProxyCacheUtils.DEFAULT_BUFFER_SIZE];
135 | int readBytes;
136 | while ((readBytes = source.read(buffer)) != -1 && !Thread.currentThread().isInterrupted() && !stopped) {
137 | if (isLogEnabled()) {
138 | Log.d(LOG_TAG, "Write data[" + readBytes + " bytes] to cache from source with offset " + offset + ": " + ProxyCacheUtils.preview(buffer, readBytes));
139 | }
140 | cache.append(buffer, readBytes);
141 | offset += readBytes;
142 | cachePercentage = offset * 100 / source.available();
143 |
144 | notifyNewCacheDataAvailable(cachePercentage);
145 | }
146 | if (cache.available() == source.available()) {
147 | cache.complete();
148 | }
149 | } catch (Throwable e) {
150 | readSourceErrorsCount.incrementAndGet();
151 | onError(e);
152 | } finally {
153 | closeSource();
154 | notifyNewCacheDataAvailable(cachePercentage);
155 | }
156 | }
157 |
158 | private void closeSource() {
159 | try {
160 | source.close();
161 | } catch (ProxyCacheException e) {
162 | onError(new ProxyCacheException("Error closing source " + source, e));
163 | }
164 | }
165 |
166 | protected final void onError(final Throwable e) {
167 | Log.e(LOG_TAG, "ProxyCache error", e);
168 | handler.post(new ErrorDeliverer(e));
169 | }
170 |
171 | protected boolean isLogEnabled() {
172 | return logEnabled;
173 | }
174 |
175 | private class SourceReaderRunnable implements Runnable {
176 |
177 | @Override
178 | public void run() {
179 | readSource();
180 | }
181 | }
182 |
183 | private class ErrorDeliverer implements Runnable {
184 |
185 | private final Throwable error;
186 |
187 | public ErrorDeliverer(Throwable error) {
188 | this.error = error;
189 | }
190 |
191 | @Override
192 | public void run() {
193 | if (error instanceof ProxyCacheException) {
194 | if (cacheListener != null) {
195 | cacheListener.onError((ProxyCacheException) error);
196 | }
197 | } else {
198 | throw new RuntimeException("Unexpected error!", error);
199 | }
200 | }
201 | }
202 | }
203 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/ProxyCacheException.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache;
2 |
3 | /**
4 | * Indicates any error in work of {@link ProxyCache}.
5 | *
6 | * @author Alexey Danilov
7 | */
8 | public class ProxyCacheException extends Exception {
9 |
10 | public ProxyCacheException(String message) {
11 | super(message);
12 | }
13 |
14 | public ProxyCacheException(String message, Throwable cause) {
15 | super(message, cause);
16 | }
17 |
18 | public ProxyCacheException(Throwable cause) {
19 | super(cause);
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/ProxyCacheUtils.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache;
2 |
3 | import android.text.TextUtils;
4 | import android.webkit.MimeTypeMap;
5 |
6 | import java.io.File;
7 | import java.io.IOException;
8 | import java.util.Arrays;
9 |
10 | import static com.danikula.videocache.Preconditions.checkArgument;
11 | import static com.danikula.videocache.Preconditions.checkNotNull;
12 |
13 | /**
14 | * Just simple utils.
15 | *
16 | * @author Alexey Danilov (danikula@gmail.com).
17 | */
18 | class ProxyCacheUtils {
19 |
20 | static final String LOG_TAG = "ProxyCache";
21 | static final int DEFAULT_BUFFER_SIZE = 8 * 1024;
22 | static final int MAX_ARRAY_PREVIEW = 16;
23 |
24 | static String getSupposablyMime(String url) {
25 | MimeTypeMap mimes = MimeTypeMap.getSingleton();
26 | String extension = MimeTypeMap.getFileExtensionFromUrl(url);
27 | return TextUtils.isEmpty(extension) ? null : mimes.getMimeTypeFromExtension(extension);
28 | }
29 |
30 | static void assertBuffer(byte[] buffer, long offset, int length) {
31 | checkNotNull(buffer, "Buffer must be not null!");
32 | checkArgument(offset >= 0, "Data offset must be positive!");
33 | checkArgument(length >= 0 && length <= buffer.length, "Length must be in range [0..buffer.length]");
34 | }
35 |
36 | static String preview(byte[] data, int length) {
37 | int previewLength = Math.min(MAX_ARRAY_PREVIEW, Math.max(length, 0));
38 | byte[] dataRange = Arrays.copyOfRange(data, 0, previewLength);
39 | String preview = Arrays.toString(dataRange);
40 | if (previewLength < length) {
41 | preview = preview.substring(0, preview.length() - 1) + ", ...]";
42 | }
43 | return preview;
44 | }
45 |
46 | static void createDirectory(File directory) throws IOException {
47 | checkNotNull(directory, "File must be not null!");
48 | if (directory.exists()) {
49 | checkArgument(directory.isDirectory(), "File is not directory!");
50 | } else {
51 | boolean isCreated = directory.mkdirs();
52 | if (!isCreated) {
53 | String error = String.format("Directory %s can't be created", directory.getAbsolutePath());
54 | throw new IOException(error);
55 | }
56 | }
57 | }
58 |
59 |
60 | }
61 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/Source.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache;
2 |
3 | /**
4 | * Source for proxy.
5 | *
6 | * @author Alexey Danilov (danikula@gmail.com).
7 | */
8 | public interface Source {
9 |
10 | int available() throws ProxyCacheException;
11 |
12 | void open(int offset) throws ProxyCacheException;
13 |
14 | void close() throws ProxyCacheException;
15 |
16 | int read(byte[] buffer) throws ProxyCacheException;
17 | }
18 |
--------------------------------------------------------------------------------
/sample/build.gradle:
--------------------------------------------------------------------------------
1 | apply plugin: 'com.android.application'
2 |
3 | android {
4 | compileSdkVersion 22
5 | buildToolsVersion '22.0.1'
6 |
7 | defaultConfig {
8 | applicationId "com.danikula.videocache.sample"
9 | minSdkVersion 15
10 | targetSdkVersion 22
11 | versionCode 1
12 | versionName '1.0'
13 | }
14 | }
15 |
16 | repositories {
17 | maven { url 'https://dl.bintray.com/alexeydanilov/maven' }
18 |
19 | }
20 |
21 | dependencies {
22 | compile 'com.danikula:videocache:1.0.1'
23 | compile 'com.google.android.exoplayer:exoplayer:r1.3.3'
24 | }
25 |
--------------------------------------------------------------------------------
/sample/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
2 |
5 |
6 |
7 |
8 |
9 |
10 |
15 |
18 |
19 |
20 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
--------------------------------------------------------------------------------
/sample/src/main/java/com/com/exoplayer/player/DebugTrackRenderer.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2014 The Android Open Source Project
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.com.exoplayer.player;
17 |
18 | import android.widget.TextView;
19 |
20 | import com.google.android.exoplayer.ExoPlaybackException;
21 | import com.google.android.exoplayer.MediaCodecTrackRenderer;
22 | import com.google.android.exoplayer.TrackRenderer;
23 | import com.google.android.exoplayer.chunk.Format;
24 |
25 | /**
26 | * A {@link TrackRenderer} that periodically updates debugging information displayed by a
27 | * {@link TextView}.
28 | */
29 | /* package */ class DebugTrackRenderer extends TrackRenderer implements Runnable {
30 |
31 | private final TextView textView;
32 | private final DemoPlayer player;
33 | private final MediaCodecTrackRenderer renderer;
34 |
35 | private volatile boolean pendingFailure;
36 | private volatile long currentPositionUs;
37 |
38 | public DebugTrackRenderer(TextView textView, DemoPlayer player,
39 | MediaCodecTrackRenderer renderer) {
40 | this.textView = textView;
41 | this.player = player;
42 | this.renderer = renderer;
43 | }
44 |
45 | public void injectFailure() {
46 | pendingFailure = true;
47 | }
48 |
49 | @Override
50 | protected boolean isEnded() {
51 | return true;
52 | }
53 |
54 | @Override
55 | protected boolean isReady() {
56 | return true;
57 | }
58 |
59 | @Override
60 | protected int doPrepare(long positionUs) throws ExoPlaybackException {
61 | maybeFail();
62 | return STATE_PREPARED;
63 | }
64 |
65 | @Override
66 | protected void doSomeWork(long positionUs, long elapsedRealtimeUs) throws ExoPlaybackException {
67 | maybeFail();
68 | if (positionUs < currentPositionUs || positionUs > currentPositionUs + 1000000) {
69 | currentPositionUs = positionUs;
70 | textView.post(this);
71 | }
72 | }
73 |
74 | @Override
75 | public void run() {
76 | textView.setText(getRenderString());
77 | }
78 |
79 | private String getRenderString() {
80 | return getQualityString() + " " + renderer.codecCounters.getDebugString();
81 | }
82 |
83 | private String getQualityString() {
84 | Format format = player.getVideoFormat();
85 | return format == null ? "id:? br:? h:?"
86 | : "id:" + format.id + " br:" + format.bitrate + " h:" + format.height;
87 | }
88 |
89 | @Override
90 | protected long getCurrentPositionUs() {
91 | return currentPositionUs;
92 | }
93 |
94 | @Override
95 | protected long getDurationUs() {
96 | return TrackRenderer.MATCH_LONGEST_US;
97 | }
98 |
99 | @Override
100 | protected long getBufferedPositionUs() {
101 | return TrackRenderer.END_OF_TRACK_US;
102 | }
103 |
104 | @Override
105 | protected void seekTo(long timeUs) {
106 | currentPositionUs = timeUs;
107 | }
108 |
109 | private void maybeFail() throws ExoPlaybackException {
110 | if (pendingFailure) {
111 | pendingFailure = false;
112 | throw new ExoPlaybackException("fail() was called on DebugTrackRenderer");
113 | }
114 | }
115 |
116 | }
117 |
--------------------------------------------------------------------------------
/sample/src/main/java/com/com/exoplayer/player/DemoPlayer.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2014 The Android Open Source Project
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.com.exoplayer.player;
17 |
18 | import android.media.MediaCodec.CryptoException;
19 | import android.os.Handler;
20 | import android.os.Looper;
21 | import android.view.Surface;
22 |
23 | import com.google.android.exoplayer.DummyTrackRenderer;
24 | import com.google.android.exoplayer.ExoPlaybackException;
25 | import com.google.android.exoplayer.ExoPlayer;
26 | import com.google.android.exoplayer.MediaCodecAudioTrackRenderer;
27 | import com.google.android.exoplayer.MediaCodecTrackRenderer.DecoderInitializationException;
28 | import com.google.android.exoplayer.MediaCodecVideoTrackRenderer;
29 | import com.google.android.exoplayer.TrackRenderer;
30 | import com.google.android.exoplayer.audio.AudioTrack;
31 | import com.google.android.exoplayer.chunk.ChunkSampleSource;
32 | import com.google.android.exoplayer.chunk.Format;
33 | import com.google.android.exoplayer.chunk.MultiTrackChunkSource;
34 | import com.google.android.exoplayer.drm.StreamingDrmSessionManager;
35 | import com.google.android.exoplayer.hls.HlsSampleSource;
36 | import com.google.android.exoplayer.metadata.MetadataTrackRenderer;
37 | import com.google.android.exoplayer.text.TextRenderer;
38 | import com.google.android.exoplayer.upstream.DefaultBandwidthMeter;
39 | import com.google.android.exoplayer.util.PlayerControl;
40 |
41 | import java.io.IOException;
42 | import java.util.Map;
43 | import java.util.concurrent.CopyOnWriteArrayList;
44 |
45 | /**
46 | * A wrapper around {@link ExoPlayer} that provides a higher level interface. It can be prepared
47 | * with one of a number of {@link RendererBuilder} classes to suit different use cases (e.g. DASH,
48 | * SmoothStreaming and so on).
49 | */
50 | public class DemoPlayer implements ExoPlayer.Listener, ChunkSampleSource.EventListener,
51 | HlsSampleSource.EventListener, DefaultBandwidthMeter.EventListener,
52 | MediaCodecVideoTrackRenderer.EventListener, MediaCodecAudioTrackRenderer.EventListener,
53 | StreamingDrmSessionManager.EventListener, TextRenderer {
54 |
55 | /**
56 | * Builds renderers for the player.
57 | */
58 | public interface RendererBuilder {
59 | /**
60 | * Constructs the necessary components for playback.
61 | *
62 | * @param player The parent player.
63 | * @param callback The callback to invoke with the constructed components.
64 | */
65 | void buildRenderers(DemoPlayer player, RendererBuilderCallback callback);
66 | }
67 |
68 | /**
69 | * A callback invoked by a {@link RendererBuilder}.
70 | */
71 | public interface RendererBuilderCallback {
72 | /**
73 | * Invoked with the results from a {@link RendererBuilder}.
74 | *
75 | * @param trackNames The names of the available tracks, indexed by {@link DemoPlayer} TYPE_*
76 | * constants. May be null if the track names are unknown. An individual element may be null
77 | * if the track names are unknown for the corresponding type.
78 | * @param multiTrackSources Sources capable of switching between multiple available tracks,
79 | * indexed by {@link DemoPlayer} TYPE_* constants. May be null if there are no types with
80 | * multiple tracks. An individual element may be null if it does not have multiple tracks.
81 | * @param renderers Renderers indexed by {@link DemoPlayer} TYPE_* constants. An individual
82 | * element may be null if there do not exist tracks of the corresponding type.
83 | */
84 | void onRenderers(String[][] trackNames, MultiTrackChunkSource[] multiTrackSources,
85 | TrackRenderer[] renderers);
86 | /**
87 | * Invoked if a {@link RendererBuilder} encounters an error.
88 | *
89 | * @param e Describes the error.
90 | */
91 | void onRenderersError(Exception e);
92 | }
93 |
94 | /**
95 | * A listener for core events.
96 | */
97 | public interface Listener {
98 | void onStateChanged(boolean playWhenReady, int playbackState);
99 | void onError(Exception e);
100 | void onVideoSizeChanged(int width, int height, float pixelWidthHeightRatio);
101 | }
102 |
103 | /**
104 | * A listener for internal errors.
105 | *
106 | * These errors are not visible to the user, and hence this listener is provided for
107 | * informational purposes only. Note however that an internal error may cause a fatal
108 | * error if the player fails to recover. If this happens, {@link Listener#onError(Exception)}
109 | * will be invoked.
110 | */
111 | public interface InternalErrorListener {
112 | void onRendererInitializationError(Exception e);
113 | void onAudioTrackInitializationError(AudioTrack.InitializationException e);
114 | void onAudioTrackWriteError(AudioTrack.WriteException e);
115 | void onDecoderInitializationError(DecoderInitializationException e);
116 | void onCryptoError(CryptoException e);
117 | void onLoadError(int sourceId, IOException e);
118 | void onDrmSessionManagerError(Exception e);
119 | }
120 |
121 | /**
122 | * A listener for debugging information.
123 | */
124 | public interface InfoListener {
125 | void onVideoFormatEnabled(Format format, int trigger, int mediaTimeMs);
126 | void onAudioFormatEnabled(Format format, int trigger, int mediaTimeMs);
127 | void onDroppedFrames(int count, long elapsed);
128 | void onBandwidthSample(int elapsedMs, long bytes, long bitrateEstimate);
129 | void onLoadStarted(int sourceId, long length, int type, int trigger, Format format,
130 | int mediaStartTimeMs, int mediaEndTimeMs);
131 | void onLoadCompleted(int sourceId, long bytesLoaded, int type, int trigger, Format format,
132 | int mediaStartTimeMs, int mediaEndTimeMs, long elapsedRealtimeMs, long loadDurationMs);
133 | void onDecoderInitialized(String decoderName, long elapsedRealtimeMs,
134 | long initializationDurationMs);
135 | }
136 |
137 | /**
138 | * A listener for receiving notifications of timed text.
139 | */
140 | public interface TextListener {
141 | void onText(String text);
142 | }
143 |
144 | /**
145 | * A listener for receiving ID3 metadata parsed from the media stream.
146 | */
147 | public interface Id3MetadataListener {
148 | void onId3Metadata(Map metadata);
149 | }
150 |
151 | // Constants pulled into this class for convenience.
152 | public static final int STATE_IDLE = ExoPlayer.STATE_IDLE;
153 | public static final int STATE_PREPARING = ExoPlayer.STATE_PREPARING;
154 | public static final int STATE_BUFFERING = ExoPlayer.STATE_BUFFERING;
155 | public static final int STATE_READY = ExoPlayer.STATE_READY;
156 | public static final int STATE_ENDED = ExoPlayer.STATE_ENDED;
157 |
158 | public static final int DISABLED_TRACK = -1;
159 | public static final int PRIMARY_TRACK = 0;
160 |
161 | public static final int RENDERER_COUNT = 5;
162 | public static final int TYPE_VIDEO = 0;
163 | public static final int TYPE_AUDIO = 1;
164 | public static final int TYPE_TEXT = 2;
165 | public static final int TYPE_TIMED_METADATA = 3;
166 | public static final int TYPE_DEBUG = 4;
167 |
168 | private static final int RENDERER_BUILDING_STATE_IDLE = 1;
169 | private static final int RENDERER_BUILDING_STATE_BUILDING = 2;
170 | private static final int RENDERER_BUILDING_STATE_BUILT = 3;
171 |
172 | private final RendererBuilder rendererBuilder;
173 | private final ExoPlayer player;
174 | private final PlayerControl playerControl;
175 | private final Handler mainHandler;
176 | private final CopyOnWriteArrayList listeners;
177 |
178 | private int rendererBuildingState;
179 | private int lastReportedPlaybackState;
180 | private boolean lastReportedPlayWhenReady;
181 |
182 | private Surface surface;
183 | private InternalRendererBuilderCallback builderCallback;
184 | private TrackRenderer videoRenderer;
185 | private Format videoFormat;
186 | private int videoTrackToRestore;
187 |
188 | private MultiTrackChunkSource[] multiTrackSources;
189 | private String[][] trackNames;
190 | private int[] selectedTracks;
191 | private boolean backgrounded;
192 |
193 | private TextListener textListener;
194 | private Id3MetadataListener id3MetadataListener;
195 | private InternalErrorListener internalErrorListener;
196 | private InfoListener infoListener;
197 |
198 | public DemoPlayer(RendererBuilder rendererBuilder) {
199 | this.rendererBuilder = rendererBuilder;
200 | player = ExoPlayer.Factory.newInstance(RENDERER_COUNT, 1000, 5000);
201 | player.addListener(this);
202 | playerControl = new PlayerControl(player);
203 | mainHandler = new Handler();
204 | listeners = new CopyOnWriteArrayList();
205 | lastReportedPlaybackState = STATE_IDLE;
206 | rendererBuildingState = RENDERER_BUILDING_STATE_IDLE;
207 | selectedTracks = new int[RENDERER_COUNT];
208 | // Disable text initially.
209 | selectedTracks[TYPE_TEXT] = DISABLED_TRACK;
210 | }
211 |
212 | public PlayerControl getPlayerControl() {
213 | return playerControl;
214 | }
215 |
216 | public void addListener(Listener listener) {
217 | listeners.add(listener);
218 | }
219 |
220 | public void removeListener(Listener listener) {
221 | listeners.remove(listener);
222 | }
223 |
224 | public void setInternalErrorListener(InternalErrorListener listener) {
225 | internalErrorListener = listener;
226 | }
227 |
228 | public void setInfoListener(InfoListener listener) {
229 | infoListener = listener;
230 | }
231 |
232 | public void setTextListener(TextListener listener) {
233 | textListener = listener;
234 | }
235 |
236 | public void setMetadataListener(Id3MetadataListener listener) {
237 | id3MetadataListener = listener;
238 | }
239 |
240 | public void setSurface(Surface surface) {
241 | this.surface = surface;
242 | pushSurface(false);
243 | }
244 |
245 | public Surface getSurface() {
246 | return surface;
247 | }
248 |
249 | public void blockingClearSurface() {
250 | surface = null;
251 | pushSurface(true);
252 | }
253 |
254 | public String[] getTracks(int type) {
255 | return trackNames == null ? null : trackNames[type];
256 | }
257 |
258 | public int getSelectedTrackIndex(int type) {
259 | return selectedTracks[type];
260 | }
261 |
262 | public void selectTrack(int type, int index) {
263 | if (selectedTracks[type] == index) {
264 | return;
265 | }
266 | selectedTracks[type] = index;
267 | pushTrackSelection(type, true);
268 | if (type == TYPE_TEXT && index == DISABLED_TRACK && textListener != null) {
269 | textListener.onText(null);
270 | }
271 | }
272 |
273 | public Format getVideoFormat() {
274 | return videoFormat;
275 | }
276 |
277 | public void setBackgrounded(boolean backgrounded) {
278 | if (this.backgrounded == backgrounded) {
279 | return;
280 | }
281 | this.backgrounded = backgrounded;
282 | if (backgrounded) {
283 | videoTrackToRestore = getSelectedTrackIndex(TYPE_VIDEO);
284 | selectTrack(TYPE_VIDEO, DISABLED_TRACK);
285 | blockingClearSurface();
286 | } else {
287 | selectTrack(TYPE_VIDEO, videoTrackToRestore);
288 | }
289 | }
290 |
291 | public void prepare() {
292 | if (rendererBuildingState == RENDERER_BUILDING_STATE_BUILT) {
293 | player.stop();
294 | }
295 | if (builderCallback != null) {
296 | builderCallback.cancel();
297 | }
298 | videoFormat = null;
299 | videoRenderer = null;
300 | multiTrackSources = null;
301 | rendererBuildingState = RENDERER_BUILDING_STATE_BUILDING;
302 | maybeReportPlayerState();
303 | builderCallback = new InternalRendererBuilderCallback();
304 | rendererBuilder.buildRenderers(this, builderCallback);
305 | }
306 |
307 | /* package */ void onRenderers(String[][] trackNames,
308 | MultiTrackChunkSource[] multiTrackSources, TrackRenderer[] renderers) {
309 | builderCallback = null;
310 | // Normalize the results.
311 | if (trackNames == null) {
312 | trackNames = new String[RENDERER_COUNT][];
313 | }
314 | if (multiTrackSources == null) {
315 | multiTrackSources = new MultiTrackChunkSource[RENDERER_COUNT];
316 | }
317 | for (int i = 0; i < RENDERER_COUNT; i++) {
318 | if (renderers[i] == null) {
319 | // Convert a null renderer to a dummy renderer.
320 | renderers[i] = new DummyTrackRenderer();
321 | } else if (trackNames[i] == null) {
322 | // We have a renderer so we must have at least one track, but the names are unknown.
323 | // Initialize the correct number of null track names.
324 | int trackCount = multiTrackSources[i] == null ? 1 : multiTrackSources[i].getTrackCount();
325 | trackNames[i] = new String[trackCount];
326 | }
327 | }
328 | // Complete preparation.
329 | this.trackNames = trackNames;
330 | this.videoRenderer = renderers[TYPE_VIDEO];
331 | this.multiTrackSources = multiTrackSources;
332 | pushSurface(false);
333 | pushTrackSelection(TYPE_VIDEO, true);
334 | pushTrackSelection(TYPE_AUDIO, true);
335 | pushTrackSelection(TYPE_TEXT, true);
336 | player.prepare(renderers);
337 | rendererBuildingState = RENDERER_BUILDING_STATE_BUILT;
338 | }
339 |
340 | /* package */ void onRenderersError(Exception e) {
341 | builderCallback = null;
342 | if (internalErrorListener != null) {
343 | internalErrorListener.onRendererInitializationError(e);
344 | }
345 | for (Listener listener : listeners) {
346 | listener.onError(e);
347 | }
348 | rendererBuildingState = RENDERER_BUILDING_STATE_IDLE;
349 | maybeReportPlayerState();
350 | }
351 |
352 | public void setPlayWhenReady(boolean playWhenReady) {
353 | player.setPlayWhenReady(playWhenReady);
354 | }
355 |
356 | public void seekTo(long positionMs) {
357 | player.seekTo(positionMs);
358 | }
359 |
360 | public void release() {
361 | if (builderCallback != null) {
362 | builderCallback.cancel();
363 | builderCallback = null;
364 | }
365 | rendererBuildingState = RENDERER_BUILDING_STATE_IDLE;
366 | surface = null;
367 | player.release();
368 | }
369 |
370 |
371 | public int getPlaybackState() {
372 | if (rendererBuildingState == RENDERER_BUILDING_STATE_BUILDING) {
373 | return ExoPlayer.STATE_PREPARING;
374 | }
375 | int playerState = player.getPlaybackState();
376 | if (rendererBuildingState == RENDERER_BUILDING_STATE_BUILT
377 | && rendererBuildingState == RENDERER_BUILDING_STATE_IDLE) {
378 | // This is an edge case where the renderers are built, but are still being passed to the
379 | // player's playback thread.
380 | return ExoPlayer.STATE_PREPARING;
381 | }
382 | return playerState;
383 | }
384 |
385 | public long getCurrentPosition() {
386 | return player.getCurrentPosition();
387 | }
388 |
389 | public long getDuration() {
390 | return player.getDuration();
391 | }
392 |
393 | public int getBufferedPercentage() {
394 | return player.getBufferedPercentage();
395 | }
396 |
397 | public boolean getPlayWhenReady() {
398 | return player.getPlayWhenReady();
399 | }
400 |
401 | /* package */ Looper getPlaybackLooper() {
402 | return player.getPlaybackLooper();
403 | }
404 |
405 | /* package */ Handler getMainHandler() {
406 | return mainHandler;
407 | }
408 |
409 | @Override
410 | public void onPlayerStateChanged(boolean playWhenReady, int state) {
411 | maybeReportPlayerState();
412 | }
413 |
414 | @Override
415 | public void onPlayerError(ExoPlaybackException exception) {
416 | rendererBuildingState = RENDERER_BUILDING_STATE_IDLE;
417 | for (Listener listener : listeners) {
418 | listener.onError(exception);
419 | }
420 | }
421 |
422 | @Override
423 | public void onVideoSizeChanged(int width, int height, float pixelWidthHeightRatio) {
424 | for (Listener listener : listeners) {
425 | listener.onVideoSizeChanged(width, height, pixelWidthHeightRatio);
426 | }
427 | }
428 |
429 | @Override
430 | public void onDroppedFrames(int count, long elapsed) {
431 | if (infoListener != null) {
432 | infoListener.onDroppedFrames(count, elapsed);
433 | }
434 | }
435 |
436 | @Override
437 | public void onBandwidthSample(int elapsedMs, long bytes, long bitrateEstimate) {
438 | if (infoListener != null) {
439 | infoListener.onBandwidthSample(elapsedMs, bytes, bitrateEstimate);
440 | }
441 | }
442 |
443 | @Override
444 | public void onDownstreamFormatChanged(int sourceId, Format format, int trigger, int mediaTimeMs) {
445 | if (infoListener == null) {
446 | return;
447 | }
448 | if (sourceId == TYPE_VIDEO) {
449 | videoFormat = format;
450 | infoListener.onVideoFormatEnabled(format, trigger, mediaTimeMs);
451 | } else if (sourceId == TYPE_AUDIO) {
452 | infoListener.onAudioFormatEnabled(format, trigger, mediaTimeMs);
453 | }
454 | }
455 |
456 | @Override
457 | public void onDrmSessionManagerError(Exception e) {
458 | if (internalErrorListener != null) {
459 | internalErrorListener.onDrmSessionManagerError(e);
460 | }
461 | }
462 |
463 | @Override
464 | public void onDecoderInitializationError(DecoderInitializationException e) {
465 | if (internalErrorListener != null) {
466 | internalErrorListener.onDecoderInitializationError(e);
467 | }
468 | }
469 |
470 | @Override
471 | public void onAudioTrackInitializationError(AudioTrack.InitializationException e) {
472 | if (internalErrorListener != null) {
473 | internalErrorListener.onAudioTrackInitializationError(e);
474 | }
475 | }
476 |
477 | @Override
478 | public void onAudioTrackWriteError(AudioTrack.WriteException e) {
479 | if (internalErrorListener != null) {
480 | internalErrorListener.onAudioTrackWriteError(e);
481 | }
482 | }
483 |
484 | @Override
485 | public void onCryptoError(CryptoException e) {
486 | if (internalErrorListener != null) {
487 | internalErrorListener.onCryptoError(e);
488 | }
489 | }
490 |
491 | @Override
492 | public void onDecoderInitialized(
493 | String decoderName,
494 | long elapsedRealtimeMs,
495 | long initializationDurationMs) {
496 | if (infoListener != null) {
497 | infoListener.onDecoderInitialized(decoderName, elapsedRealtimeMs, initializationDurationMs);
498 | }
499 | }
500 |
501 | @Override
502 | public void onLoadError(int sourceId, IOException e) {
503 | if (internalErrorListener != null) {
504 | internalErrorListener.onLoadError(sourceId, e);
505 | }
506 | }
507 |
508 | @Override
509 | public void onText(String text) {
510 | processText(text);
511 | }
512 |
513 | /* package */ MetadataTrackRenderer.MetadataRenderer>
514 | getId3MetadataRenderer() {
515 | return new MetadataTrackRenderer.MetadataRenderer>() {
516 | @Override
517 | public void onMetadata(Map metadata) {
518 | if (id3MetadataListener != null) {
519 | id3MetadataListener.onId3Metadata(metadata);
520 | }
521 | }
522 | };
523 | }
524 |
525 | @Override
526 | public void onPlayWhenReadyCommitted() {
527 | // Do nothing.
528 | }
529 |
530 | @Override
531 | public void onDrawnToSurface(Surface surface) {
532 | // Do nothing.
533 | }
534 |
535 | @Override
536 | public void onLoadStarted(int sourceId, long length, int type, int trigger, Format format,
537 | int mediaStartTimeMs, int mediaEndTimeMs) {
538 | if (infoListener != null) {
539 | infoListener.onLoadStarted(sourceId, length, type, trigger, format, mediaStartTimeMs,
540 | mediaEndTimeMs);
541 | }
542 | }
543 |
544 | @Override
545 | public void onLoadCompleted(int sourceId, long bytesLoaded, int type, int trigger, Format format,
546 | int mediaStartTimeMs, int mediaEndTimeMs, long elapsedRealtimeMs, long loadDurationMs) {
547 | if (infoListener != null) {
548 | infoListener.onLoadCompleted(sourceId, bytesLoaded, type, trigger, format, mediaStartTimeMs,
549 | mediaEndTimeMs, elapsedRealtimeMs, loadDurationMs);
550 | }
551 | }
552 |
553 | @Override
554 | public void onLoadCanceled(int sourceId, long bytesLoaded) {
555 | // Do nothing.
556 | }
557 |
558 | @Override
559 | public void onUpstreamDiscarded(int sourceId, int mediaStartTimeMs, int mediaEndTimeMs) {
560 | // Do nothing.
561 | }
562 |
563 | private void maybeReportPlayerState() {
564 | boolean playWhenReady = player.getPlayWhenReady();
565 | int playbackState = getPlaybackState();
566 | if (lastReportedPlayWhenReady != playWhenReady || lastReportedPlaybackState != playbackState) {
567 | for (Listener listener : listeners) {
568 | listener.onStateChanged(playWhenReady, playbackState);
569 | }
570 | lastReportedPlayWhenReady = playWhenReady;
571 | lastReportedPlaybackState = playbackState;
572 | }
573 | }
574 |
575 | private void pushSurface(boolean blockForSurfacePush) {
576 | if (videoRenderer == null) {
577 | return;
578 | }
579 |
580 | if (blockForSurfacePush) {
581 | player.blockingSendMessage(
582 | videoRenderer, MediaCodecVideoTrackRenderer.MSG_SET_SURFACE, surface);
583 | } else {
584 | player.sendMessage(
585 | videoRenderer, MediaCodecVideoTrackRenderer.MSG_SET_SURFACE, surface);
586 | }
587 | }
588 |
589 | private void pushTrackSelection(int type, boolean allowRendererEnable) {
590 | if (multiTrackSources == null) {
591 | return;
592 | }
593 |
594 | int trackIndex = selectedTracks[type];
595 | if (trackIndex == DISABLED_TRACK) {
596 | player.setRendererEnabled(type, false);
597 | } else if (multiTrackSources[type] == null) {
598 | player.setRendererEnabled(type, allowRendererEnable);
599 | } else {
600 | boolean playWhenReady = player.getPlayWhenReady();
601 | player.setPlayWhenReady(false);
602 | player.setRendererEnabled(type, false);
603 | player.sendMessage(multiTrackSources[type], MultiTrackChunkSource.MSG_SELECT_TRACK,
604 | trackIndex);
605 | player.setRendererEnabled(type, allowRendererEnable);
606 | player.setPlayWhenReady(playWhenReady);
607 | }
608 | }
609 |
610 | /* package */ void processText(String text) {
611 | if (textListener == null || selectedTracks[TYPE_TEXT] == DISABLED_TRACK) {
612 | return;
613 | }
614 | textListener.onText(text);
615 | }
616 |
617 | private class InternalRendererBuilderCallback implements RendererBuilderCallback {
618 |
619 | private boolean canceled;
620 |
621 | public void cancel() {
622 | canceled = true;
623 | }
624 |
625 | @Override
626 | public void onRenderers(String[][] trackNames, MultiTrackChunkSource[] multiTrackSources,
627 | TrackRenderer[] renderers) {
628 | if (!canceled) {
629 | DemoPlayer.this.onRenderers(trackNames, multiTrackSources, renderers);
630 | }
631 | }
632 |
633 | @Override
634 | public void onRenderersError(Exception e) {
635 | if (!canceled) {
636 | DemoPlayer.this.onRenderersError(e);
637 | }
638 | }
639 |
640 | }
641 |
642 | }
643 |
--------------------------------------------------------------------------------
/sample/src/main/java/com/com/exoplayer/player/HlsRendererBuilder.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2014 The Android Open Source Project
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.com.exoplayer.player;
17 |
18 | import android.content.Context;
19 | import android.media.MediaCodec;
20 | import android.os.Handler;
21 | import android.widget.TextView;
22 |
23 | import com.com.exoplayer.player.DemoPlayer.RendererBuilderCallback;
24 | import com.google.android.exoplayer.MediaCodecAudioTrackRenderer;
25 | import com.google.android.exoplayer.MediaCodecUtil.DecoderQueryException;
26 | import com.google.android.exoplayer.MediaCodecVideoTrackRenderer;
27 | import com.google.android.exoplayer.TrackRenderer;
28 | import com.google.android.exoplayer.audio.AudioCapabilities;
29 | import com.google.android.exoplayer.chunk.VideoFormatSelectorUtil;
30 | import com.google.android.exoplayer.hls.HlsChunkSource;
31 | import com.google.android.exoplayer.hls.HlsMasterPlaylist;
32 | import com.google.android.exoplayer.hls.HlsPlaylist;
33 | import com.google.android.exoplayer.hls.HlsPlaylistParser;
34 | import com.google.android.exoplayer.hls.HlsSampleSource;
35 | import com.google.android.exoplayer.metadata.Id3Parser;
36 | import com.google.android.exoplayer.metadata.MetadataTrackRenderer;
37 | import com.google.android.exoplayer.text.eia608.Eia608TrackRenderer;
38 | import com.google.android.exoplayer.upstream.DataSource;
39 | import com.google.android.exoplayer.upstream.DefaultBandwidthMeter;
40 | import com.google.android.exoplayer.upstream.DefaultUriDataSource;
41 | import com.google.android.exoplayer.util.ManifestFetcher;
42 | import com.google.android.exoplayer.util.ManifestFetcher.ManifestCallback;
43 |
44 | import java.io.IOException;
45 | import java.util.Map;
46 |
47 |
48 | public class HlsRendererBuilder implements DemoPlayer.RendererBuilder, ManifestCallback {
49 |
50 | private static final int REQUESTED_BUFFER_SIZE = 18 * 1024 * 1024;
51 | private static final long REQUESTED_BUFFER_DURATION_MS = 40000;
52 |
53 | private final Context context;
54 | private final String userAgent;
55 | private final String url;
56 | private final TextView debugTextView;
57 | private final AudioCapabilities audioCapabilities;
58 |
59 | private DemoPlayer player;
60 | private RendererBuilderCallback callback;
61 |
62 | public HlsRendererBuilder(Context context, String userAgent, String url, TextView debugTextView,
63 | AudioCapabilities audioCapabilities) {
64 | this.context = context;
65 | this.userAgent = userAgent;
66 | this.url = url;
67 | this.debugTextView = debugTextView;
68 | this.audioCapabilities = audioCapabilities;
69 | }
70 |
71 | @Override
72 | public void buildRenderers(DemoPlayer player, RendererBuilderCallback callback) {
73 | this.player = player;
74 | this.callback = callback;
75 | HlsPlaylistParser parser = new HlsPlaylistParser();
76 | ManifestFetcher playlistFetcher = new ManifestFetcher(url,
77 | new DefaultUriDataSource(context, userAgent), parser);
78 | playlistFetcher.singleLoad(player.getMainHandler().getLooper(), this);
79 | }
80 |
81 | @Override
82 | public void onSingleManifestError(IOException e) {
83 | callback.onRenderersError(e);
84 | }
85 |
86 | @Override
87 | public void onSingleManifest(HlsPlaylist manifest) {
88 | Handler mainHandler = player.getMainHandler();
89 | DefaultBandwidthMeter bandwidthMeter = new DefaultBandwidthMeter();
90 |
91 | int[] variantIndices = null;
92 | if (manifest instanceof HlsMasterPlaylist) {
93 | HlsMasterPlaylist masterPlaylist = (HlsMasterPlaylist) manifest;
94 | try {
95 | variantIndices = VideoFormatSelectorUtil.selectVideoFormatsForDefaultDisplay(
96 | context, masterPlaylist.variants, null, false);
97 | } catch (DecoderQueryException e) {
98 | callback.onRenderersError(e);
99 | return;
100 | }
101 | }
102 |
103 | DataSource dataSource = new DefaultUriDataSource(context, bandwidthMeter, userAgent);
104 | HlsChunkSource chunkSource = new HlsChunkSource(dataSource, url, manifest, bandwidthMeter,
105 | variantIndices, HlsChunkSource.ADAPTIVE_MODE_SPLICE, audioCapabilities);
106 | HlsSampleSource sampleSource = new HlsSampleSource(chunkSource, true, 3, REQUESTED_BUFFER_SIZE,
107 | REQUESTED_BUFFER_DURATION_MS, mainHandler, player, DemoPlayer.TYPE_VIDEO);
108 | MediaCodecVideoTrackRenderer videoRenderer = new MediaCodecVideoTrackRenderer(sampleSource,
109 | MediaCodec.VIDEO_SCALING_MODE_SCALE_TO_FIT, 5000, mainHandler, player, 50);
110 | MediaCodecAudioTrackRenderer audioRenderer = new MediaCodecAudioTrackRenderer(sampleSource);
111 |
112 | MetadataTrackRenderer> id3Renderer =
113 | new MetadataTrackRenderer>(sampleSource, new Id3Parser(),
114 | player.getId3MetadataRenderer(), mainHandler.getLooper());
115 |
116 | Eia608TrackRenderer closedCaptionRenderer = new Eia608TrackRenderer(sampleSource, player,
117 | mainHandler.getLooper());
118 |
119 | // Build the debug renderer.
120 | TrackRenderer debugRenderer = debugTextView != null
121 | ? new DebugTrackRenderer(debugTextView, player, videoRenderer) : null;
122 |
123 | TrackRenderer[] renderers = new TrackRenderer[DemoPlayer.RENDERER_COUNT];
124 | renderers[DemoPlayer.TYPE_VIDEO] = videoRenderer;
125 | renderers[DemoPlayer.TYPE_AUDIO] = audioRenderer;
126 | renderers[DemoPlayer.TYPE_TIMED_METADATA] = id3Renderer;
127 | renderers[DemoPlayer.TYPE_TEXT] = closedCaptionRenderer;
128 | renderers[DemoPlayer.TYPE_DEBUG] = debugRenderer;
129 | callback.onRenderers(null, null, renderers);
130 | }
131 |
132 |
133 | }
134 |
--------------------------------------------------------------------------------
/sample/src/main/java/com/com/exoplayer/player/PlayerActivity.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2014 The Android Open Source Project
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.com.exoplayer.player;
17 |
18 | import android.app.Activity;
19 | import android.os.Bundle;
20 | import android.view.KeyEvent;
21 | import android.view.MotionEvent;
22 | import android.view.SurfaceHolder;
23 | import android.view.View;
24 | import android.view.View.OnClickListener;
25 | import android.view.View.OnKeyListener;
26 | import android.view.View.OnTouchListener;
27 | import android.widget.MediaController;
28 |
29 | import com.danikula.videocache.sample.R;
30 | import com.google.android.exoplayer.ExoPlayer;
31 | import com.google.android.exoplayer.VideoSurfaceView;
32 | import com.google.android.exoplayer.audio.AudioCapabilities;
33 | import com.google.android.exoplayer.audio.AudioCapabilitiesReceiver;
34 | import com.google.android.exoplayer.util.Util;
35 |
36 | /**
37 | * An activity that plays media using {@link DemoPlayer}.
38 | */
39 | public class PlayerActivity extends Activity implements SurfaceHolder.Callback, OnClickListener,
40 | DemoPlayer.Listener,
41 | AudioCapabilitiesReceiver.Listener {
42 |
43 | private MediaController mediaController;
44 | private VideoSurfaceView surfaceView;
45 |
46 | private DemoPlayer player;
47 | private boolean playerNeedsPrepare;
48 | private long playerPosition;
49 |
50 | private String VIDEO_URL;
51 |
52 | private AudioCapabilitiesReceiver audioCapabilitiesReceiver;
53 | private AudioCapabilities audioCapabilities;
54 |
55 | // Activity lifecycle
56 |
57 | @Override
58 | public void onCreate(Bundle savedInstanceState) {
59 | super.onCreate(savedInstanceState);
60 |
61 | VIDEO_URL = "http://stream-1.vdomax.com:1935/vod/__definst__/mp4:youlove/youlove_xxx_7043.mp4/playlist.m3u8";
62 |
63 | setContentView(R.layout.player_activity);
64 | View root = findViewById(R.id.root);
65 | root.setOnTouchListener(new OnTouchListener() {
66 | @Override
67 | public boolean onTouch(View view, MotionEvent motionEvent) {
68 | if (motionEvent.getAction() == MotionEvent.ACTION_DOWN) {
69 | toggleControlsVisibility();
70 | } else if (motionEvent.getAction() == MotionEvent.ACTION_UP) {
71 | view.performClick();
72 | }
73 | return true;
74 | }
75 | });
76 | root.setOnKeyListener(new OnKeyListener() {
77 | @Override
78 | public boolean onKey(View v, int keyCode, KeyEvent event) {
79 | if (keyCode == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) {
80 | return mediaController.dispatchKeyEvent(event);
81 | }
82 | return false;
83 | }
84 | });
85 | audioCapabilitiesReceiver = new AudioCapabilitiesReceiver(getApplicationContext(), this);
86 |
87 |
88 | surfaceView = (VideoSurfaceView) findViewById(R.id.surface_view);
89 | surfaceView.getHolder().addCallback(this);
90 |
91 | mediaController = new MediaController(this);
92 | mediaController.setAnchorView(root);
93 |
94 | preparePlayer();
95 |
96 | //DemoUtil.setDefaultCookieManager();
97 | }
98 |
99 | @Override
100 | public void onResume() {
101 | super.onResume();
102 | //configureSubtitleView();
103 |
104 | // The player will be prepared on receiving audio capabilities.
105 | audioCapabilitiesReceiver.register();
106 | }
107 |
108 | @Override
109 | public void onPause() {
110 | super.onPause();
111 | if (!true) {
112 | releasePlayer();
113 | } else {
114 | player.setBackgrounded(true);
115 | }
116 | audioCapabilitiesReceiver.unregister();
117 |
118 | }
119 |
120 | @Override
121 | public void onDestroy() {
122 | super.onDestroy();
123 | releasePlayer();
124 | }
125 |
126 | // OnClickListener methods
127 |
128 | @Override
129 | public void onClick(View view) {
130 | //if (view == retryButton) {
131 | //preparePlayer();
132 | //}
133 | }
134 |
135 | // AudioCapabilitiesReceiver.Listener methods
136 |
137 | @Override
138 | public void onAudioCapabilitiesChanged(AudioCapabilities audioCapabilities) {
139 | boolean audioCapabilitiesChanged = !audioCapabilities.equals(this.audioCapabilities);
140 | if (player == null || audioCapabilitiesChanged) {
141 | this.audioCapabilities = audioCapabilities;
142 | releasePlayer();
143 | preparePlayer();
144 | } else if (player != null) {
145 | player.setBackgrounded(false);
146 | }
147 | }
148 |
149 | // Internal methods
150 |
151 |
152 |
153 | private void preparePlayer() {
154 |
155 | if (player == null) {
156 | String userAgent = Util.getUserAgent(this, "ExoPlayerDemo");
157 | player = new DemoPlayer(new HlsRendererBuilder(this, userAgent, VIDEO_URL.toString(), null,
158 | audioCapabilities));
159 | player.addListener(this);
160 | player.seekTo(playerPosition);
161 | playerNeedsPrepare = true;
162 | mediaController.setMediaPlayer(player.getPlayerControl());
163 | mediaController.setEnabled(true);
164 |
165 | }
166 | if (playerNeedsPrepare) {
167 | player.prepare();
168 | playerNeedsPrepare = false;
169 | updateButtonVisibilities();
170 | }
171 | player.setSurface(surfaceView.getHolder().getSurface());
172 | player.setPlayWhenReady(true);
173 | }
174 |
175 | private void releasePlayer() {
176 | if (player != null) {
177 | playerPosition = player.getCurrentPosition();
178 | player.release();
179 | player = null;
180 | //eventLogger.endSession();
181 | //eventLogger = null;
182 | }
183 | }
184 |
185 | // DemoPlayer.Listener implementation
186 |
187 | @Override
188 | public void onStateChanged(boolean playWhenReady, int playbackState) {
189 | if (playbackState == ExoPlayer.STATE_ENDED) {
190 | showControls();
191 | }
192 | String text = "playWhenReady=" + playWhenReady + ", playbackState=";
193 | switch(playbackState) {
194 | case ExoPlayer.STATE_BUFFERING:
195 | text += "buffering";
196 | break;
197 | case ExoPlayer.STATE_ENDED:
198 | text += "ended";
199 | break;
200 | case ExoPlayer.STATE_IDLE:
201 | text += "idle";
202 | break;
203 | case ExoPlayer.STATE_PREPARING:
204 | text += "preparing";
205 | break;
206 | case ExoPlayer.STATE_READY:
207 | text += "ready";
208 | break;
209 | default:
210 | text += "unknown";
211 | break;
212 | }
213 | //playerStateTextView.setText(text);
214 | updateButtonVisibilities();
215 | }
216 |
217 | @Override
218 | public void onError(Exception e) {
219 |
220 | playerNeedsPrepare = true;
221 | updateButtonVisibilities();
222 | showControls();
223 | }
224 |
225 | @Override
226 | public void onVideoSizeChanged(int width, int height, float pixelWidthAspectRatio) {
227 | //shutterView.setVisibility(View.GONE);
228 | surfaceView.setVideoWidthHeightRatio(
229 | height == 0 ? 1 : (width * pixelWidthAspectRatio) / height);
230 | }
231 |
232 | // User controls
233 |
234 | private void updateButtonVisibilities() {
235 | //retryButton.setVisibility(playerNeedsPrepare ? View.VISIBLE : View.GONE);
236 | //videoButton.setVisibility(haveTracks(DemoPlayer.TYPE_VIDEO) ? View.VISIBLE : View.GONE);
237 | //audioButton.setVisibility(haveTracks(DemoPlayer.TYPE_AUDIO) ? View.VISIBLE : View.GONE);
238 | //textButton.setVisibility(haveTracks(DemoPlayer.TYPE_TEXT) ? View.VISIBLE : View.GONE);
239 | }
240 |
241 |
242 | private void toggleControlsVisibility() {
243 | if (mediaController.isShowing()) {
244 | mediaController.hide();
245 | //debugRootView.setVisibility(View.GONE);
246 | } else {
247 | showControls();
248 | }
249 | }
250 |
251 | private void showControls() {
252 | mediaController.show(0);
253 | //debugRootView.setVisibility(View.VISIBLE);
254 | }
255 |
256 | // DemoPlayer.TextListener implementation
257 |
258 |
259 | // SurfaceHolder.Callback implementation
260 |
261 | @Override
262 | public void surfaceCreated(SurfaceHolder holder) {
263 | if (player != null) {
264 | player.setSurface(holder.getSurface());
265 | }
266 | }
267 |
268 | @Override
269 | public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
270 | // Do nothing.
271 | }
272 |
273 | @Override
274 | public void surfaceDestroyed(SurfaceHolder holder) {
275 | if (player != null) {
276 | player.blockingClearSurface();
277 | }
278 | }
279 |
280 |
281 |
282 | }
283 |
--------------------------------------------------------------------------------
/sample/src/main/java/com/danikula/videocache/sample/VideoCacheActivity.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.sample;
2 |
3 | import android.annotation.SuppressLint;
4 | import android.app.Activity;
5 | import android.content.Context;
6 | import android.content.res.Configuration;
7 | import android.media.AudioManager;
8 | import android.media.MediaPlayer;
9 | import android.net.Uri;
10 | import android.os.Bundle;
11 | import android.os.Handler;
12 | import android.os.Message;
13 | import android.util.Log;
14 | import android.view.MotionEvent;
15 | import android.view.View;
16 | import android.view.animation.Animation;
17 | import android.view.animation.AnimationUtils;
18 | import android.widget.ImageView;
19 | import android.widget.ProgressBar;
20 | import android.widget.SeekBar;
21 | import android.widget.TextView;
22 |
23 | import com.danikula.videocache.Cache;
24 | import com.danikula.videocache.CacheListener;
25 | import com.danikula.videocache.FileCache;
26 | import com.danikula.videocache.HttpProxyCache;
27 | import com.danikula.videocache.HttpUrlSource;
28 | import com.danikula.videocache.ProxyCacheException;
29 | import com.jit.video.DensityUtil;
30 | import com.jit.video.FullScreenVideoView;
31 | import com.jit.video.LightnessController;
32 | import com.jit.video.VolumnController;
33 |
34 | import java.io.File;
35 | import java.text.DateFormat;
36 | import java.text.SimpleDateFormat;
37 | import java.util.Date;
38 | import java.util.Timer;
39 | import java.util.TimerTask;
40 |
41 | public class VideoCacheActivity extends Activity implements CacheListener,View.OnClickListener {
42 |
43 | private static final String LOG_TAG = "VideoActivity";
44 | private static final String VIDEO_CACHE_NAME = "X4gPz_110559_60765d771b815d6faadf2f978fb8fcfe_ori.mp4";
45 | private static final String VIDEO_URL = "http://stream-1.vdomax.com:1935/vod/__definst__/mp4:youlove/youlove_xxx_7043.mp4/playlist.m3u8";
46 |
47 | //private static final String VIDEO_URL = "http://stream-1.vdomax.com:1935/vod/__definst__/mp4:110559/110559_720p.mp4/playlist.m3u8";
48 |
49 |
50 | //private static final String VIDEO_URL ="https://www.vdomax.com/clips/2015/05/X4gPz_110559_60765d771b815d6faadf2f978fb8fcfe_ori.mp4";
51 |
52 | //private VideoView videoView;
53 |
54 | //private String videoUrl = "https://www.vdomax.com/clips/2015/05/X4gPz_110559_60765d771b815d6faadf2f978fb8fcfe_ori.mp4";
55 |
56 |
57 |
58 | private ProgressBar progressBar;
59 | private HttpProxyCache proxyCache;
60 |
61 | private FullScreenVideoView mVideo;
62 | private View mTopView;
63 | private View mBottomView;
64 | private SeekBar mSeekBar;
65 | private ImageView mPlay;
66 | private TextView mPlayTime;
67 | private TextView mDurationTime;
68 |
69 | private AudioManager mAudioManager;
70 |
71 | private float width;
72 | private float height;
73 |
74 | private int playTime;
75 |
76 |
77 | private static final int HIDE_TIME = 5000;
78 |
79 | private VolumnController volumnController;
80 |
81 | private int orginalLight;
82 |
83 | @Override
84 | protected void onCreate(Bundle savedInstanceState) {
85 | super.onCreate(savedInstanceState);
86 |
87 | setUpUi();
88 | playVideo();
89 | }
90 |
91 | private void setUpUi() {
92 | setContentView(R.layout.activity_video);
93 | //videoView = (VideoView) findViewById(R.id.videoView);
94 | progressBar = (ProgressBar) findViewById(R.id.progressBar);
95 | progressBar.setMax(100);
96 |
97 | volumnController = new VolumnController(this);
98 | mVideo = (FullScreenVideoView) findViewById(R.id.videoview);
99 | mPlayTime = (TextView) findViewById(R.id.play_time);
100 | mDurationTime = (TextView) findViewById(R.id.total_time);
101 | mPlay = (ImageView) findViewById(R.id.play_btn);
102 | mSeekBar = (SeekBar) findViewById(R.id.seekbar);
103 | mTopView = findViewById(R.id.top_layout);
104 | mBottomView = findViewById(R.id.bottom_layout);
105 |
106 | mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
107 |
108 | width = DensityUtil.getWidthInPx(this);
109 | height = DensityUtil.getHeightInPx(this);
110 | threshold = DensityUtil.dip2px(this, 18);
111 |
112 | orginalLight = LightnessController.getLightness(this);
113 |
114 | mPlay.setOnClickListener(this);
115 | mSeekBar.setOnSeekBarChangeListener(mSeekBarChangeListener);
116 |
117 | //playVideo();
118 |
119 | }
120 |
121 | private void playVideo() {
122 |
123 | runOnUiThread(new Runnable() {
124 | @Override
125 | public void run() {
126 | mVideo.setVideoURI(Uri.parse(VIDEO_URL));
127 | }
128 | });
129 |
130 | //mVideo.setVideoPath(VIDEO_URL);
131 | mVideo.requestFocus();
132 | mVideo.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
133 | @Override
134 | public void onPrepared(MediaPlayer mp) {
135 | mVideo.setVideoWidth(mp.getVideoWidth());
136 | mVideo.setVideoHeight(mp.getVideoHeight());
137 |
138 | mVideo.start();
139 | if (playTime != 0) {
140 | mVideo.seekTo(playTime);
141 | }
142 |
143 | mHandler.removeCallbacks(hideRunnable);
144 | mHandler.postDelayed(hideRunnable, HIDE_TIME);
145 | mDurationTime.setText(formatTime(mVideo.getDuration()));
146 | Timer timer = new Timer();
147 | timer.schedule(new TimerTask() {
148 |
149 | @Override
150 | public void run() {
151 | mHandler.sendEmptyMessage(1);
152 | }
153 | }, 0, 1000);
154 | }
155 | });
156 | mVideo.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
157 | @Override
158 | public void onCompletion(MediaPlayer mp) {
159 | mPlay.setImageResource(R.drawable.video_btn_down);
160 | mPlayTime.setText("00:00");
161 | mSeekBar.setProgress(0);
162 | }
163 | });
164 | mVideo.setOnTouchListener(mTouchListener);
165 | }
166 |
167 |
168 |
169 | private void playWithCache() {
170 | try {
171 | Cache cache = new FileCache(new File(getExternalCacheDir(), VIDEO_CACHE_NAME));
172 | HttpUrlSource source = new HttpUrlSource(VIDEO_URL);
173 | proxyCache = new HttpProxyCache(source, cache);
174 | proxyCache.setCacheListener(this);
175 | mVideo.setVideoPath(proxyCache.getUrl());
176 | mVideo.start();
177 | } catch (ProxyCacheException e) {
178 | // do nothing. onError() handles all errors
179 | }
180 | }
181 |
182 | @Override
183 | public void onConfigurationChanged(Configuration newConfig) {
184 | if (this.getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
185 | height = DensityUtil.getWidthInPx(this);
186 | width = DensityUtil.getHeightInPx(this);
187 | } else if (this.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT) {
188 | width = DensityUtil.getWidthInPx(this);
189 | height = DensityUtil.getHeightInPx(this);
190 | }
191 | super.onConfigurationChanged(newConfig);
192 | }
193 |
194 | @Override
195 | public void onDestroy() {
196 | super.onDestroy();
197 |
198 | mHandler.removeMessages(0);
199 | mHandler.removeCallbacksAndMessages(null);
200 |
201 | if (proxyCache != null) {
202 | proxyCache.shutdown();
203 | }
204 | }
205 |
206 | @Override
207 | public void onError(ProxyCacheException e) {
208 | Log.e(LOG_TAG, "Error playing video", e);
209 | }
210 |
211 | @Override
212 | public void onCacheDataAvailable(int cachePercentage) {
213 | progressBar.setProgress(cachePercentage);
214 | }
215 |
216 | private SeekBar.OnSeekBarChangeListener mSeekBarChangeListener = new SeekBar.OnSeekBarChangeListener() {
217 |
218 | @Override
219 | public void onStopTrackingTouch(SeekBar seekBar) {
220 | mHandler.postDelayed(hideRunnable, HIDE_TIME);
221 | }
222 |
223 | @Override
224 | public void onStartTrackingTouch(SeekBar seekBar) {
225 | mHandler.removeCallbacks(hideRunnable);
226 | }
227 |
228 | @Override
229 | public void onProgressChanged(SeekBar seekBar, int progress,
230 | boolean fromUser) {
231 | if (fromUser) {
232 | int time = progress * mVideo.getDuration() / 100;
233 | mVideo.seekTo(time);
234 | }
235 | }
236 | };
237 |
238 | private void backward(float delataX) {
239 | int current = mVideo.getCurrentPosition();
240 | int backwardTime = (int) (delataX / width * mVideo.getDuration());
241 | int currentTime = current - backwardTime;
242 | mVideo.seekTo(currentTime);
243 | mSeekBar.setProgress(currentTime * 100 / mVideo.getDuration());
244 | mPlayTime.setText(formatTime(currentTime));
245 | }
246 |
247 | private void forward(float delataX) {
248 | int current = mVideo.getCurrentPosition();
249 | int forwardTime = (int) (delataX / width * mVideo.getDuration());
250 | int currentTime = current + forwardTime;
251 | mVideo.seekTo(currentTime);
252 | mSeekBar.setProgress(currentTime * 100 / mVideo.getDuration());
253 | mPlayTime.setText(formatTime(currentTime));
254 | }
255 |
256 | private void volumeDown(float delatY) {
257 | int max = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
258 | int current = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
259 | int down = (int) (delatY / height * max * 3);
260 | int volume = Math.max(current - down, 0);
261 | mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, volume, 0);
262 | int transformatVolume = volume * 100 / max;
263 | volumnController.show(transformatVolume);
264 | }
265 |
266 | private void volumeUp(float delatY) {
267 | int max = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
268 | int current = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
269 | int up = (int) ((delatY / height) * max * 3);
270 | int volume = Math.min(current + up, max);
271 | mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, volume, 0);
272 | int transformatVolume = volume * 100 / max;
273 | volumnController.show(transformatVolume);
274 | }
275 |
276 | private void lightDown(float delatY) {
277 | int down = (int) (delatY / height * 255 * 3);
278 | int transformatLight = LightnessController.getLightness(this) - down;
279 | LightnessController.setLightness(this, transformatLight);
280 | }
281 |
282 | private void lightUp(float delatY) {
283 | int up = (int) (delatY / height * 255 * 3);
284 | int transformatLight = LightnessController.getLightness(this) + up;
285 | LightnessController.setLightness(this, transformatLight);
286 | }
287 |
288 |
289 | @SuppressLint("HandlerLeak")
290 | private Handler mHandler = new Handler() {
291 |
292 | @Override
293 | public void handleMessage(Message msg) {
294 | super.handleMessage(msg);
295 | switch (msg.what) {
296 | case 1:
297 | if (mVideo.getCurrentPosition() > 0) {
298 | mPlayTime.setText(formatTime(mVideo.getCurrentPosition()));
299 | int progress = mVideo.getCurrentPosition() * 100 / mVideo.getDuration();
300 | mSeekBar.setProgress(progress);
301 | if (mVideo.getCurrentPosition() > mVideo.getDuration() - 100) {
302 | mPlayTime.setText("00:00");
303 | mSeekBar.setProgress(0);
304 | }
305 | mSeekBar.setSecondaryProgress(mVideo.getBufferPercentage());
306 | } else {
307 | mPlayTime.setText("00:00");
308 | mSeekBar.setProgress(0);
309 | }
310 |
311 | break;
312 | case 2:
313 | showOrHide();
314 | break;
315 |
316 | default:
317 | break;
318 | }
319 | }
320 | };
321 |
322 |
323 |
324 |
325 | private Runnable hideRunnable = new Runnable() {
326 |
327 | @Override
328 | public void run() {
329 | showOrHide();
330 | }
331 | };
332 |
333 | @SuppressLint("SimpleDateFormat")
334 | private String formatTime(long time) {
335 | DateFormat formatter = new SimpleDateFormat("mm:ss");
336 | return formatter.format(new Date(time));
337 | }
338 |
339 | private float mLastMotionX;
340 | private float mLastMotionY;
341 | private int startX;
342 | private int startY;
343 | private int threshold;
344 | private boolean isClick = true;
345 |
346 | private View.OnTouchListener mTouchListener = new View.OnTouchListener() {
347 |
348 | @Override
349 | public boolean onTouch(View v, MotionEvent event) {
350 | final float x = event.getX();
351 | final float y = event.getY();
352 |
353 | switch (event.getAction()) {
354 | case MotionEvent.ACTION_DOWN:
355 | mLastMotionX = x;
356 | mLastMotionY = y;
357 | startX = (int) x;
358 | startY = (int) y;
359 | break;
360 | case MotionEvent.ACTION_MOVE:
361 | float deltaX = x - mLastMotionX;
362 | float deltaY = y - mLastMotionY;
363 | float absDeltaX = Math.abs(deltaX);
364 | float absDeltaY = Math.abs(deltaY);
365 | // 声音调节标识
366 | boolean isAdjustAudio = false;
367 | if (absDeltaX > threshold && absDeltaY > threshold) {
368 | if (absDeltaX < absDeltaY) {
369 | isAdjustAudio = true;
370 | } else {
371 | isAdjustAudio = false;
372 | }
373 | } else if (absDeltaX < threshold && absDeltaY > threshold) {
374 | isAdjustAudio = true;
375 | } else if (absDeltaX > threshold && absDeltaY < threshold) {
376 | isAdjustAudio = false;
377 | } else {
378 | return true;
379 | }
380 | if (isAdjustAudio) {
381 | if (x < width / 2) {
382 | if (deltaY > 0) {
383 | lightDown(absDeltaY);
384 | } else if (deltaY < 0) {
385 | lightUp(absDeltaY);
386 | }
387 | } else {
388 | if (deltaY > 0) {
389 | volumeDown(absDeltaY);
390 | } else if (deltaY < 0) {
391 | volumeUp(absDeltaY);
392 | }
393 | }
394 |
395 | } else {
396 | if (deltaX > 0) {
397 | forward(absDeltaX);
398 | } else if (deltaX < 0) {
399 | backward(absDeltaX);
400 | }
401 | }
402 | mLastMotionX = x;
403 | mLastMotionY = y;
404 | break;
405 | case MotionEvent.ACTION_UP:
406 | if (Math.abs(x - startX) > threshold
407 | || Math.abs(y - startY) > threshold) {
408 | isClick = false;
409 | }
410 | mLastMotionX = 0;
411 | mLastMotionY = 0;
412 | startX = (int) 0;
413 | if (isClick) {
414 | showOrHide();
415 | }
416 | isClick = true;
417 | break;
418 |
419 | default:
420 | break;
421 | }
422 | return true;
423 | }
424 |
425 | };
426 |
427 | @Override
428 | public void onClick(View v) {
429 | switch (v.getId()) {
430 | case R.id.play_btn:
431 | if (mVideo.isPlaying()) {
432 | mVideo.pause();
433 | mPlay.setImageResource(R.drawable.video_btn_down);
434 | } else {
435 | mVideo.start();
436 | mPlay.setImageResource(R.drawable.video_btn_on);
437 | }
438 | break;
439 | default:
440 | break;
441 | }
442 | }
443 |
444 | private void showOrHide() {
445 | if (mTopView.getVisibility() == View.VISIBLE) {
446 | mTopView.clearAnimation();
447 | Animation animation = AnimationUtils.loadAnimation(this,
448 | R.anim.option_leave_from_top);
449 | animation.setAnimationListener(new AnimationImp() {
450 | @Override
451 | public void onAnimationEnd(Animation animation) {
452 | super.onAnimationEnd(animation);
453 | mTopView.setVisibility(View.GONE);
454 | }
455 | });
456 | mTopView.startAnimation(animation);
457 |
458 | mBottomView.clearAnimation();
459 | Animation animation1 = AnimationUtils.loadAnimation(this,
460 | R.anim.option_leave_from_bottom);
461 | animation1.setAnimationListener(new AnimationImp() {
462 | @Override
463 | public void onAnimationEnd(Animation animation) {
464 | super.onAnimationEnd(animation);
465 | mBottomView.setVisibility(View.GONE);
466 | }
467 | });
468 | mBottomView.startAnimation(animation1);
469 | } else {
470 | mTopView.setVisibility(View.VISIBLE);
471 | mTopView.clearAnimation();
472 | Animation animation = AnimationUtils.loadAnimation(this,
473 | R.anim.option_entry_from_top);
474 | mTopView.startAnimation(animation);
475 |
476 | mBottomView.setVisibility(View.VISIBLE);
477 | mBottomView.clearAnimation();
478 | Animation animation1 = AnimationUtils.loadAnimation(this,
479 | R.anim.option_entry_from_bottom);
480 | mBottomView.startAnimation(animation1);
481 | mHandler.removeCallbacks(hideRunnable);
482 | mHandler.postDelayed(hideRunnable, HIDE_TIME);
483 | }
484 | }
485 |
486 | private class AnimationImp implements Animation.AnimationListener {
487 |
488 | @Override
489 | public void onAnimationEnd(Animation animation) {
490 |
491 | }
492 |
493 | @Override
494 | public void onAnimationRepeat(Animation animation) {
495 | }
496 |
497 | @Override
498 | public void onAnimationStart(Animation animation) {
499 | }
500 |
501 | }
502 |
503 | }
504 |
--------------------------------------------------------------------------------
/sample/src/main/java/com/jit/video/AdvancedVideoActivity.java:
--------------------------------------------------------------------------------
1 | package com.jit.video;
2 |
3 | import android.annotation.SuppressLint;
4 | import android.app.Activity;
5 | import android.content.Context;
6 | import android.content.res.Configuration;
7 | import android.media.AudioManager;
8 | import android.media.MediaPlayer;
9 | import android.media.MediaPlayer.OnCompletionListener;
10 | import android.media.MediaPlayer.OnPreparedListener;
11 | import android.os.Bundle;
12 | import android.os.Handler;
13 | import android.os.Message;
14 | import android.view.MotionEvent;
15 | import android.view.View;
16 | import android.view.View.OnClickListener;
17 | import android.view.View.OnTouchListener;
18 | import android.view.animation.Animation;
19 | import android.view.animation.Animation.AnimationListener;
20 | import android.view.animation.AnimationUtils;
21 | import android.widget.ImageView;
22 | import android.widget.SeekBar;
23 | import android.widget.SeekBar.OnSeekBarChangeListener;
24 | import android.widget.TextView;
25 |
26 | import com.danikula.videocache.sample.R;
27 |
28 | import java.text.DateFormat;
29 | import java.text.SimpleDateFormat;
30 | import java.util.Date;
31 | import java.util.Timer;
32 | import java.util.TimerTask;
33 |
34 | public class AdvancedVideoActivity extends Activity implements OnClickListener {
35 |
36 | // 自定义VideoView
37 | private FullScreenVideoView mVideo;
38 |
39 | // 头部View
40 | private View mTopView;
41 |
42 | // 底部View
43 | private View mBottomView;
44 | // 视频播放拖动条
45 | private SeekBar mSeekBar;
46 | private ImageView mPlay;
47 | private TextView mPlayTime;
48 | private TextView mDurationTime;
49 |
50 | // 音频管理器
51 | private AudioManager mAudioManager;
52 |
53 | // 屏幕宽高
54 | private float width;
55 | private float height;
56 |
57 | // 视频播放时间
58 | private int playTime;
59 |
60 | private String videoUrl = "https://www.vdomax.com/clips/2015/05/X4gPz_110559_60765d771b815d6faadf2f978fb8fcfe_ori.mp4";
61 | // 自动隐藏顶部和底部View的时间
62 | private static final int HIDE_TIME = 5000;
63 |
64 | // 声音调节Toast
65 | private VolumnController volumnController;
66 |
67 | // 原始屏幕亮度
68 | private int orginalLight;
69 |
70 | @Override
71 | protected void onCreate(Bundle savedInstanceState) {
72 | super.onCreate(savedInstanceState);
73 | setContentView(R.layout.activity_main);
74 | volumnController = new VolumnController(this);
75 | mVideo = (FullScreenVideoView) findViewById(R.id.videoview);
76 | mPlayTime = (TextView) findViewById(R.id.play_time);
77 | mDurationTime = (TextView) findViewById(R.id.total_time);
78 | mPlay = (ImageView) findViewById(R.id.play_btn);
79 | mSeekBar = (SeekBar) findViewById(R.id.seekbar);
80 | mTopView = findViewById(R.id.top_layout);
81 | mBottomView = findViewById(R.id.bottom_layout);
82 |
83 | mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
84 |
85 | width = DensityUtil.getWidthInPx(this);
86 | height = DensityUtil.getHeightInPx(this);
87 | threshold = DensityUtil.dip2px(this, 18);
88 |
89 | orginalLight = LightnessController.getLightness(this);
90 |
91 | mPlay.setOnClickListener(this);
92 | mSeekBar.setOnSeekBarChangeListener(mSeekBarChangeListener);
93 |
94 | playVideo();
95 | }
96 |
97 | @Override
98 | public void onConfigurationChanged(Configuration newConfig) {
99 | if (this.getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
100 | height = DensityUtil.getWidthInPx(this);
101 | width = DensityUtil.getHeightInPx(this);
102 | } else if (this.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT) {
103 | width = DensityUtil.getWidthInPx(this);
104 | height = DensityUtil.getHeightInPx(this);
105 | }
106 | super.onConfigurationChanged(newConfig);
107 | }
108 |
109 | @Override
110 | protected void onPause() {
111 | super.onPause();
112 | LightnessController.setLightness(this, orginalLight);
113 | }
114 |
115 | private OnSeekBarChangeListener mSeekBarChangeListener = new OnSeekBarChangeListener() {
116 |
117 | @Override
118 | public void onStopTrackingTouch(SeekBar seekBar) {
119 | mHandler.postDelayed(hideRunnable, HIDE_TIME);
120 | }
121 |
122 | @Override
123 | public void onStartTrackingTouch(SeekBar seekBar) {
124 | mHandler.removeCallbacks(hideRunnable);
125 | }
126 |
127 | @Override
128 | public void onProgressChanged(SeekBar seekBar, int progress,
129 | boolean fromUser) {
130 | if (fromUser) {
131 | int time = progress * mVideo.getDuration() / 100;
132 | mVideo.seekTo(time);
133 | }
134 | }
135 | };
136 |
137 | private void backward(float delataX) {
138 | int current = mVideo.getCurrentPosition();
139 | int backwardTime = (int) (delataX / width * mVideo.getDuration());
140 | int currentTime = current - backwardTime;
141 | mVideo.seekTo(currentTime);
142 | mSeekBar.setProgress(currentTime * 100 / mVideo.getDuration());
143 | mPlayTime.setText(formatTime(currentTime));
144 | }
145 |
146 | private void forward(float delataX) {
147 | int current = mVideo.getCurrentPosition();
148 | int forwardTime = (int) (delataX / width * mVideo.getDuration());
149 | int currentTime = current + forwardTime;
150 | mVideo.seekTo(currentTime);
151 | mSeekBar.setProgress(currentTime * 100 / mVideo.getDuration());
152 | mPlayTime.setText(formatTime(currentTime));
153 | }
154 |
155 | private void volumeDown(float delatY) {
156 | int max = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
157 | int current = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
158 | int down = (int) (delatY / height * max * 3);
159 | int volume = Math.max(current - down, 0);
160 | mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, volume, 0);
161 | int transformatVolume = volume * 100 / max;
162 | volumnController.show(transformatVolume);
163 | }
164 |
165 | private void volumeUp(float delatY) {
166 | int max = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
167 | int current = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
168 | int up = (int) ((delatY / height) * max * 3);
169 | int volume = Math.min(current + up, max);
170 | mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, volume, 0);
171 | int transformatVolume = volume * 100 / max;
172 | volumnController.show(transformatVolume);
173 | }
174 |
175 | private void lightDown(float delatY) {
176 | int down = (int) (delatY / height * 255 * 3);
177 | int transformatLight = LightnessController.getLightness(this) - down;
178 | LightnessController.setLightness(this, transformatLight);
179 | }
180 |
181 | private void lightUp(float delatY) {
182 | int up = (int) (delatY / height * 255 * 3);
183 | int transformatLight = LightnessController.getLightness(this) + up;
184 | LightnessController.setLightness(this, transformatLight);
185 | }
186 |
187 | @Override
188 | protected void onDestroy() {
189 | super.onDestroy();
190 | mHandler.removeMessages(0);
191 | mHandler.removeCallbacksAndMessages(null);
192 | }
193 |
194 | @SuppressLint("HandlerLeak")
195 | private Handler mHandler = new Handler() {
196 |
197 | @Override
198 | public void handleMessage(Message msg) {
199 | super.handleMessage(msg);
200 | switch (msg.what) {
201 | case 1:
202 | if (mVideo.getCurrentPosition() > 0) {
203 | mPlayTime.setText(formatTime(mVideo.getCurrentPosition()));
204 | int progress = mVideo.getCurrentPosition() * 100 / mVideo.getDuration();
205 | mSeekBar.setProgress(progress);
206 | if (mVideo.getCurrentPosition() > mVideo.getDuration() - 100) {
207 | mPlayTime.setText("00:00");
208 | mSeekBar.setProgress(0);
209 | }
210 | mSeekBar.setSecondaryProgress(mVideo.getBufferPercentage());
211 | } else {
212 | mPlayTime.setText("00:00");
213 | mSeekBar.setProgress(0);
214 | }
215 |
216 | break;
217 | case 2:
218 | showOrHide();
219 | break;
220 |
221 | default:
222 | break;
223 | }
224 | }
225 | };
226 |
227 | private void playVideo() {
228 | mVideo.setVideoPath(videoUrl);
229 | mVideo.requestFocus();
230 | mVideo.setOnPreparedListener(new OnPreparedListener() {
231 | @Override
232 | public void onPrepared(MediaPlayer mp) {
233 | mVideo.setVideoWidth(mp.getVideoWidth());
234 | mVideo.setVideoHeight(mp.getVideoHeight());
235 |
236 | mVideo.start();
237 | if (playTime != 0) {
238 | mVideo.seekTo(playTime);
239 | }
240 |
241 | mHandler.removeCallbacks(hideRunnable);
242 | mHandler.postDelayed(hideRunnable, HIDE_TIME);
243 | mDurationTime.setText(formatTime(mVideo.getDuration()));
244 | Timer timer = new Timer();
245 | timer.schedule(new TimerTask() {
246 |
247 | @Override
248 | public void run() {
249 | mHandler.sendEmptyMessage(1);
250 | }
251 | }, 0, 1000);
252 | }
253 | });
254 | mVideo.setOnCompletionListener(new OnCompletionListener() {
255 | @Override
256 | public void onCompletion(MediaPlayer mp) {
257 | mPlay.setImageResource(R.drawable.video_btn_down);
258 | mPlayTime.setText("00:00");
259 | mSeekBar.setProgress(0);
260 | }
261 | });
262 | mVideo.setOnTouchListener(mTouchListener);
263 | }
264 |
265 | private Runnable hideRunnable = new Runnable() {
266 |
267 | @Override
268 | public void run() {
269 | showOrHide();
270 | }
271 | };
272 |
273 | @SuppressLint("SimpleDateFormat")
274 | private String formatTime(long time) {
275 | DateFormat formatter = new SimpleDateFormat("mm:ss");
276 | return formatter.format(new Date(time));
277 | }
278 |
279 | private float mLastMotionX;
280 | private float mLastMotionY;
281 | private int startX;
282 | private int startY;
283 | private int threshold;
284 | private boolean isClick = true;
285 |
286 | private OnTouchListener mTouchListener = new OnTouchListener() {
287 |
288 | @Override
289 | public boolean onTouch(View v, MotionEvent event) {
290 | final float x = event.getX();
291 | final float y = event.getY();
292 |
293 | switch (event.getAction()) {
294 | case MotionEvent.ACTION_DOWN:
295 | mLastMotionX = x;
296 | mLastMotionY = y;
297 | startX = (int) x;
298 | startY = (int) y;
299 | break;
300 | case MotionEvent.ACTION_MOVE:
301 | float deltaX = x - mLastMotionX;
302 | float deltaY = y - mLastMotionY;
303 | float absDeltaX = Math.abs(deltaX);
304 | float absDeltaY = Math.abs(deltaY);
305 | // 声音调节标识
306 | boolean isAdjustAudio = false;
307 | if (absDeltaX > threshold && absDeltaY > threshold) {
308 | if (absDeltaX < absDeltaY) {
309 | isAdjustAudio = true;
310 | } else {
311 | isAdjustAudio = false;
312 | }
313 | } else if (absDeltaX < threshold && absDeltaY > threshold) {
314 | isAdjustAudio = true;
315 | } else if (absDeltaX > threshold && absDeltaY < threshold) {
316 | isAdjustAudio = false;
317 | } else {
318 | return true;
319 | }
320 | if (isAdjustAudio) {
321 | if (x < width / 2) {
322 | if (deltaY > 0) {
323 | lightDown(absDeltaY);
324 | } else if (deltaY < 0) {
325 | lightUp(absDeltaY);
326 | }
327 | } else {
328 | if (deltaY > 0) {
329 | volumeDown(absDeltaY);
330 | } else if (deltaY < 0) {
331 | volumeUp(absDeltaY);
332 | }
333 | }
334 |
335 | } else {
336 | if (deltaX > 0) {
337 | forward(absDeltaX);
338 | } else if (deltaX < 0) {
339 | backward(absDeltaX);
340 | }
341 | }
342 | mLastMotionX = x;
343 | mLastMotionY = y;
344 | break;
345 | case MotionEvent.ACTION_UP:
346 | if (Math.abs(x - startX) > threshold
347 | || Math.abs(y - startY) > threshold) {
348 | isClick = false;
349 | }
350 | mLastMotionX = 0;
351 | mLastMotionY = 0;
352 | startX = (int) 0;
353 | if (isClick) {
354 | showOrHide();
355 | }
356 | isClick = true;
357 | break;
358 |
359 | default:
360 | break;
361 | }
362 | return true;
363 | }
364 |
365 | };
366 |
367 | @Override
368 | public void onClick(View v) {
369 | switch (v.getId()) {
370 | case R.id.play_btn:
371 | if (mVideo.isPlaying()) {
372 | mVideo.pause();
373 | mPlay.setImageResource(R.drawable.video_btn_down);
374 | } else {
375 | mVideo.start();
376 | mPlay.setImageResource(R.drawable.video_btn_on);
377 | }
378 | break;
379 | default:
380 | break;
381 | }
382 | }
383 |
384 | private void showOrHide() {
385 | if (mTopView.getVisibility() == View.VISIBLE) {
386 | mTopView.clearAnimation();
387 | Animation animation = AnimationUtils.loadAnimation(this,
388 | R.anim.option_leave_from_top);
389 | animation.setAnimationListener(new AnimationImp() {
390 | @Override
391 | public void onAnimationEnd(Animation animation) {
392 | super.onAnimationEnd(animation);
393 | mTopView.setVisibility(View.GONE);
394 | }
395 | });
396 | mTopView.startAnimation(animation);
397 |
398 | mBottomView.clearAnimation();
399 | Animation animation1 = AnimationUtils.loadAnimation(this,
400 | R.anim.option_leave_from_bottom);
401 | animation1.setAnimationListener(new AnimationImp() {
402 | @Override
403 | public void onAnimationEnd(Animation animation) {
404 | super.onAnimationEnd(animation);
405 | mBottomView.setVisibility(View.GONE);
406 | }
407 | });
408 | mBottomView.startAnimation(animation1);
409 | } else {
410 | mTopView.setVisibility(View.VISIBLE);
411 | mTopView.clearAnimation();
412 | Animation animation = AnimationUtils.loadAnimation(this,
413 | R.anim.option_entry_from_top);
414 | mTopView.startAnimation(animation);
415 |
416 | mBottomView.setVisibility(View.VISIBLE);
417 | mBottomView.clearAnimation();
418 | Animation animation1 = AnimationUtils.loadAnimation(this,
419 | R.anim.option_entry_from_bottom);
420 | mBottomView.startAnimation(animation1);
421 | mHandler.removeCallbacks(hideRunnable);
422 | mHandler.postDelayed(hideRunnable, HIDE_TIME);
423 | }
424 | }
425 |
426 | private class AnimationImp implements AnimationListener {
427 |
428 | @Override
429 | public void onAnimationEnd(Animation animation) {
430 |
431 | }
432 |
433 | @Override
434 | public void onAnimationRepeat(Animation animation) {
435 | }
436 |
437 | @Override
438 | public void onAnimationStart(Animation animation) {
439 | }
440 |
441 | }
442 |
443 | }
444 |
--------------------------------------------------------------------------------
/sample/src/main/java/com/jit/video/DensityUtil.java:
--------------------------------------------------------------------------------
1 | package com.jit.video;
2 |
3 | import android.content.Context;
4 |
5 | public class DensityUtil {
6 |
7 | public static final float getHeightInPx(Context context) {
8 | final float height = context.getResources().getDisplayMetrics().heightPixels;
9 | return height;
10 | }
11 |
12 | public static final float getWidthInPx(Context context) {
13 | final float width = context.getResources().getDisplayMetrics().widthPixels;
14 | return width;
15 | }
16 |
17 | public static final int getHeightInDp(Context context) {
18 | final float height = context.getResources().getDisplayMetrics().heightPixels;
19 | int heightInDp = px2dip(context, height);
20 | return heightInDp;
21 | }
22 |
23 | public static final int getWidthInDp(Context context) {
24 | final float height = context.getResources().getDisplayMetrics().heightPixels;
25 | int widthInDp = px2dip(context, height);
26 | return widthInDp;
27 | }
28 |
29 | public static int dip2px(Context context, float dpValue) {
30 | final float scale = context.getResources().getDisplayMetrics().density;
31 | return (int) (dpValue * scale + 0.5f);
32 | }
33 |
34 | public static int px2dip(Context context, float pxValue) {
35 | final float scale = context.getResources().getDisplayMetrics().density;
36 | return (int) (pxValue / scale + 0.5f);
37 | }
38 |
39 | public static int px2sp(Context context, float pxValue) {
40 | final float scale = context.getResources().getDisplayMetrics().density;
41 | return (int) (pxValue / scale + 0.5f);
42 | }
43 |
44 | public static int sp2px(Context context, float spValue) {
45 | final float scale = context.getResources().getDisplayMetrics().density;
46 | return (int) (spValue * scale + 0.5f);
47 | }
48 |
49 | }
50 |
--------------------------------------------------------------------------------
/sample/src/main/java/com/jit/video/FullScreenSurfaceView.java:
--------------------------------------------------------------------------------
1 | package com.jit.video;
2 |
3 | import android.content.Context;
4 | import android.util.AttributeSet;
5 | import android.view.SurfaceView;
6 |
7 | /**
8 | * 自动全屏的VideoView
9 | */
10 | public class FullScreenSurfaceView extends SurfaceView {
11 |
12 | private int videoWidth;
13 | private int videoHeight;
14 |
15 | public FullScreenSurfaceView(Context context) {
16 | super(context);
17 | }
18 |
19 | public FullScreenSurfaceView(Context context, AttributeSet attrs) {
20 | super(context, attrs);
21 | }
22 |
23 | public FullScreenSurfaceView(Context context, AttributeSet attrs, int defStyle) {
24 | super(context, attrs, defStyle);
25 | }
26 |
27 | @Override
28 | protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
29 | int width = getDefaultSize(videoWidth, widthMeasureSpec);
30 | int height = getDefaultSize(videoHeight, heightMeasureSpec);
31 | if (videoWidth > 0 && videoHeight > 0) {
32 | if (videoWidth * height > width * videoHeight) {
33 | height = width * videoHeight / videoWidth;
34 | } else if (videoWidth * height < width * videoHeight) {
35 | width = height * videoWidth / videoHeight;
36 | }
37 | }
38 | setMeasuredDimension(width, height);
39 | }
40 |
41 | public int getVideoWidth() {
42 | return videoWidth;
43 | }
44 |
45 | public void setVideoWidth(int videoWidth) {
46 | this.videoWidth = videoWidth;
47 | }
48 |
49 | public int getVideoHeight() {
50 | return videoHeight;
51 | }
52 |
53 | public void setVideoHeight(int videoHeight) {
54 | this.videoHeight = videoHeight;
55 | }
56 |
57 | }
58 |
--------------------------------------------------------------------------------
/sample/src/main/java/com/jit/video/FullScreenVideoView.java:
--------------------------------------------------------------------------------
1 | package com.jit.video;
2 |
3 | import android.content.Context;
4 | import android.util.AttributeSet;
5 | import android.widget.VideoView;
6 |
7 | /**
8 | * 自动全屏的VideoView
9 | */
10 | public class FullScreenVideoView extends VideoView {
11 |
12 | private int videoWidth;
13 | private int videoHeight;
14 |
15 | public FullScreenVideoView(Context context) {
16 | super(context);
17 | }
18 |
19 | public FullScreenVideoView(Context context, AttributeSet attrs) {
20 | super(context, attrs);
21 | }
22 |
23 | public FullScreenVideoView(Context context, AttributeSet attrs, int defStyle) {
24 | super(context, attrs, defStyle);
25 | }
26 |
27 | @Override
28 | protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
29 | int width = getDefaultSize(videoWidth, widthMeasureSpec);
30 | int height = getDefaultSize(videoHeight, heightMeasureSpec);
31 | if (videoWidth > 0 && videoHeight > 0) {
32 | if (videoWidth * height > width * videoHeight) {
33 | height = width * videoHeight / videoWidth;
34 | } else if (videoWidth * height < width * videoHeight) {
35 | width = height * videoWidth / videoHeight;
36 | }
37 | }
38 | setMeasuredDimension(width, height);
39 | }
40 |
41 | public int getVideoWidth() {
42 | return videoWidth;
43 | }
44 |
45 | public void setVideoWidth(int videoWidth) {
46 | this.videoWidth = videoWidth;
47 | }
48 |
49 | public int getVideoHeight() {
50 | return videoHeight;
51 | }
52 |
53 | public void setVideoHeight(int videoHeight) {
54 | this.videoHeight = videoHeight;
55 | }
56 |
57 | }
58 |
--------------------------------------------------------------------------------
/sample/src/main/java/com/jit/video/LightnessController.java:
--------------------------------------------------------------------------------
1 | package com.jit.video;
2 |
3 | import android.app.Activity;
4 | import android.content.ContentResolver;
5 | import android.provider.Settings;
6 | import android.provider.Settings.System;
7 | import android.view.WindowManager;
8 | import android.widget.Toast;
9 |
10 | public class LightnessController {
11 |
12 | // 判断是否开启了自动亮度调节
13 | public static boolean isAutoBrightness(Activity act) {
14 | boolean automicBrightness = false;
15 | ContentResolver aContentResolver = act.getContentResolver();
16 | try {
17 | automicBrightness = Settings.System.getInt(aContentResolver,
18 | Settings.System.SCREEN_BRIGHTNESS_MODE) == Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC;
19 | } catch (Exception e) {
20 | Toast.makeText(act, "Error auto lightness", Toast.LENGTH_SHORT).show();
21 | }
22 | return automicBrightness;
23 | }
24 |
25 | // 改变亮度
26 | public static void setLightness(Activity act, int value) {
27 | try {
28 | System.putInt(act.getContentResolver(), System.SCREEN_BRIGHTNESS, value);
29 | WindowManager.LayoutParams lp = act.getWindow().getAttributes();
30 | lp.screenBrightness = (value <= 0 ? 1 : value) / 255f;
31 | act.getWindow().setAttributes(lp);
32 | } catch (Exception e) {
33 | Toast.makeText(act, "Error set lightness", Toast.LENGTH_SHORT).show();
34 | }
35 | }
36 |
37 | // 获取亮度
38 | public static int getLightness(Activity act) {
39 | return System.getInt(act.getContentResolver(), System.SCREEN_BRIGHTNESS, -1);
40 | }
41 |
42 | // 停止自动亮度调节
43 | public static void stopAutoBrightness(Activity activity) {
44 | Settings.System.putInt(activity.getContentResolver(),
45 | Settings.System.SCREEN_BRIGHTNESS_MODE,
46 | Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL);
47 | }
48 |
49 | // 开启亮度自动调节
50 | public static void startAutoBrightness(Activity activity) {
51 | Settings.System.putInt(activity.getContentResolver(),
52 | Settings.System.SCREEN_BRIGHTNESS_MODE,
53 | Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC);
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/sample/src/main/java/com/jit/video/VolumnController.java:
--------------------------------------------------------------------------------
1 | package com.jit.video;
2 |
3 | import android.content.Context;
4 | import android.view.Gravity;
5 | import android.view.LayoutInflater;
6 | import android.view.View;
7 | import android.widget.Toast;
8 |
9 | import com.danikula.videocache.sample.R;
10 |
11 | public class VolumnController {
12 | private Toast t;
13 | private VolumnView tv;
14 |
15 | private Context context;
16 |
17 | public VolumnController(Context context) {
18 | this.context = context;
19 | }
20 |
21 | public void show(float progress) {
22 | if (t == null) {
23 | t = new Toast(context);
24 | View layout = LayoutInflater.from(context).inflate(R.layout.vv, null);
25 | tv = (VolumnView) layout.findViewById(R.id.volumnView);
26 | t.setView(layout);
27 | t.setGravity(Gravity.BOTTOM, 0, 100);
28 | t.setDuration(Toast.LENGTH_SHORT);
29 | }
30 | tv.setProgress(progress);
31 | t.show();
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/sample/src/main/java/com/jit/video/VolumnView.java:
--------------------------------------------------------------------------------
1 | package com.jit.video;
2 |
3 | import android.content.Context;
4 | import android.graphics.Bitmap;
5 | import android.graphics.BitmapFactory;
6 | import android.graphics.Canvas;
7 | import android.graphics.Color;
8 | import android.graphics.Paint;
9 | import android.graphics.Paint.Style;
10 | import android.graphics.RectF;
11 | import android.util.AttributeSet;
12 | import android.view.View;
13 |
14 | import com.danikula.videocache.sample.R;
15 |
16 | /**
17 | * 仿小米声音调节环形进度条
18 | */
19 | public class VolumnView extends View {
20 |
21 | // 半径
22 | float r1 = 0;
23 | float r2 = 0;
24 | float r3 = 0;
25 | // 外圆宽度
26 | float w1 = 15;
27 | // 内圆宽度
28 | float w2 = 30;
29 | Paint paint;
30 |
31 | // 进度
32 | float progress = 0;
33 |
34 | Bitmap bitmap;
35 |
36 | RectF oval;
37 |
38 | public VolumnView(Context context, AttributeSet attrs, int defStyle) {
39 | super(context, attrs, defStyle);
40 | init(context);
41 | }
42 |
43 | public VolumnView(Context context, AttributeSet attrs) {
44 | super(context, attrs);
45 | init(context);
46 | }
47 |
48 | public VolumnView(Context context) {
49 | super(context);
50 | init(context);
51 | }
52 |
53 | void init(Context context) {
54 | paint = new Paint(Paint.ANTI_ALIAS_FLAG);
55 | paint.setStyle(Style.STROKE);
56 | bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.ic_vm);
57 | }
58 |
59 | @Override
60 | protected void onDraw(Canvas canvas) {
61 | float cx = getMeasuredWidth() / 2;
62 | float cy = getMeasuredHeight() / 2;
63 | r1 = cx - w1 / 2;
64 | r2 = cx - w1 / 2 - w2 / 2;
65 | r3 = cx - w1 / 2 - w2;
66 |
67 | // 绘制外圆
68 | paint.setStrokeWidth(w1);
69 | paint.setColor(Color.parseColor("#454547"));
70 | canvas.drawCircle(cx, cy, r1, paint);
71 |
72 | // 绘制中间圆环
73 | paint.setColor(Color.parseColor("#747476"));
74 | paint.setStrokeWidth(w2);
75 | canvas.drawCircle(cx, cy, r2, paint);
76 |
77 | // 绘制内圆
78 | paint.setColor(Color.parseColor("#464648"));
79 | paint.setStyle(Style.FILL);
80 | canvas.drawCircle(cx, cy, r3, paint);
81 |
82 | // 绘制中间的图片
83 | canvas.drawBitmap(bitmap, cx - bitmap.getWidth() / 2,
84 | cx - bitmap.getHeight() / 2, paint);
85 |
86 | // 绘制文本
87 | paint.setColor(Color.WHITE);
88 | paint.setStrokeWidth(0);
89 | paint.setTextSize(24);
90 | float textWidth = paint.measureText("Vol"); // 测量字体宽度，我们需要根据字体的宽度设置在圆环中间
91 |
92 | canvas.drawText("Vol", cx - textWidth / 2, cx + bitmap.getHeight() / 2
93 | + 24, paint);
94 |
95 | // 绘制进度
96 | paint.setStyle(Style.STROKE);
97 | paint.setStrokeWidth(w2);
98 | paint.setColor(Color.WHITE);
99 | if (oval == null) {
100 | oval = new RectF(cx - r2, cy - r2, cx + r2, cy + r2); // 用于定义的圆弧的形状和大小的界限
101 | }
102 | canvas.drawArc(oval, 270, 360 * progress / 100, false, paint);
103 |
104 | super.onDraw(canvas);
105 | }
106 |
107 | /**
108 | * 设置进度
109 | *
110 | * @param progress
111 | * 范围(0-100)
112 | */
113 | public void setProgress(float progress) {
114 | this.progress = progress;
115 | if (this.progress >= 100)
116 | this.progress = 100;
117 | if (this.progress <= 0)
118 | this.progress = 0;
119 | postInvalidate();
120 | }
121 | }
122 |
--------------------------------------------------------------------------------
/sample/src/main/res/anim/option_entry_from_bottom.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
10 |
15 |
--------------------------------------------------------------------------------
/sample/src/main/res/anim/option_entry_from_top.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
10 |
15 |
--------------------------------------------------------------------------------
/sample/src/main/res/anim/option_leave_from_bottom.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
10 |
15 |
--------------------------------------------------------------------------------
/sample/src/main/res/anim/option_leave_from_top.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
10 |
15 |
--------------------------------------------------------------------------------
/sample/src/main/res/drawable-hdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/korrio/AdvancedVideoView/b64b3702886cde5bf4ec135c4a64b10a77ee92c8/sample/src/main/res/drawable-hdpi/ic_launcher.png
--------------------------------------------------------------------------------
/sample/src/main/res/drawable-hdpi/line_point.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/korrio/AdvancedVideoView/b64b3702886cde5bf4ec135c4a64b10a77ee92c8/sample/src/main/res/drawable-hdpi/line_point.png
--------------------------------------------------------------------------------
/sample/src/main/res/drawable-hdpi/ling.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/korrio/AdvancedVideoView/b64b3702886cde5bf4ec135c4a64b10a77ee92c8/sample/src/main/res/drawable-hdpi/ling.png
--------------------------------------------------------------------------------
/sample/src/main/res/drawable-hdpi/top_btnback.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/korrio/AdvancedVideoView/b64b3702886cde5bf4ec135c4a64b10a77ee92c8/sample/src/main/res/drawable-hdpi/top_btnback.png
--------------------------------------------------------------------------------
/sample/src/main/res/drawable-hdpi/video_btn_down.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/korrio/AdvancedVideoView/b64b3702886cde5bf4ec135c4a64b10a77ee92c8/sample/src/main/res/drawable-hdpi/video_btn_down.png
--------------------------------------------------------------------------------
/sample/src/main/res/drawable-hdpi/video_btn_on.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/korrio/AdvancedVideoView/b64b3702886cde5bf4ec135c4a64b10a77ee92c8/sample/src/main/res/drawable-hdpi/video_btn_on.png
--------------------------------------------------------------------------------
/sample/src/main/res/drawable-hdpi/video_line01.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/korrio/AdvancedVideoView/b64b3702886cde5bf4ec135c4a64b10a77ee92c8/sample/src/main/res/drawable-hdpi/video_line01.png
--------------------------------------------------------------------------------
/sample/src/main/res/drawable-hdpi/video_line02.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/korrio/AdvancedVideoView/b64b3702886cde5bf4ec135c4a64b10a77ee92c8/sample/src/main/res/drawable-hdpi/video_line02.png
--------------------------------------------------------------------------------
/sample/src/main/res/drawable-mdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/korrio/AdvancedVideoView/b64b3702886cde5bf4ec135c4a64b10a77ee92c8/sample/src/main/res/drawable-mdpi/ic_launcher.png
--------------------------------------------------------------------------------
/sample/src/main/res/drawable-xhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/korrio/AdvancedVideoView/b64b3702886cde5bf4ec135c4a64b10a77ee92c8/sample/src/main/res/drawable-xhdpi/ic_launcher.png
--------------------------------------------------------------------------------
/sample/src/main/res/drawable-xhdpi/ic_vm.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/korrio/AdvancedVideoView/b64b3702886cde5bf4ec135c4a64b10a77ee92c8/sample/src/main/res/drawable-xhdpi/ic_vm.png
--------------------------------------------------------------------------------
/sample/src/main/res/drawable-xxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/korrio/AdvancedVideoView/b64b3702886cde5bf4ec135c4a64b10a77ee92c8/sample/src/main/res/drawable-xxhdpi/ic_launcher.png
--------------------------------------------------------------------------------
/sample/src/main/res/drawable/seekbar.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |