Android WebView访问网页+自动播放视频+自动全屏+切换横屏

一、引言

        近期，我发现电视家、火星直播等在线看电视直播的软件都已倒闭，而我奶奶也再无法通过这些平台看电视了。她已六十多岁，快七十岁啦。这些平台的倒下对我来说其实没有多大的影响，但是对于文化不多的她而言，生活中却是少了一大乐趣。因为自己学过编程，所以我想帮她解决这个问题。她只听得懂白话，又最爱看“广东珠江台”，因此，我通过Android的编程技术，为她专门定制一款可以自动看广东珠江台的App，打开即用，免了点来点去的麻烦。虽说需求很小、只够她一人使用，但实现起来却并不简单呀。通过两天时间的深入钻研，最终我还是把这个小需求给实现了。为此编写一篇博客，如果日后自己还需要解决这样的问题时，我就直接ctrl+c加ctrl+v。当然，也希望这篇博客能够为你提供一些指导和帮助。

二、访问网页视频+自动播放的实现思路

        由于许多的m3u8链接都已经失效，现在看电视直播只能通过一些官方网页来实现，比如央视网等等。那么，访问网页的话是可以通过Android的WebView来实现，实现的方法非常简单，就是在Activity界面之中添加一个WebView空间，然后通过下面的代码来访问网页：

1. main_wv = findViewById(R.id.main_wv);
2. main_wv.setWebViewClient(new WebViewClient());
3. main_wv.setWebChromeClient(new WebChromeClient());
4. main_wv.loadUrl("https://***.***");

        但是这样的话，最多也只能够竖屏中观看视频，显示十分地有限，而且还不会自动播放，如图：

        所以，这里先介绍实现网页访问+自动播放的思路。WebView可以通过自定义的设置来控制它是否支持JavaScript脚本注入，即通过js来实现网页视频的自动播放。第一步是对WebView进行设置，而第二步是执行js自动播放视频的脚本，代码如下：

        设置WebView支持js脚本

1. WebSettings settings = main_wv.getSettings(); // main_wv为WebView控件
2. settings.setJavaScriptEnabled(true);

        执行js自动播放视频的脚本

1. String js = "javascript:";
2. js += "var videos = document.getElementsByTagName('video');";
3. js += "var video_last;";
4. js += "var video = videos[videos.length-1];";
5. js += "if (video != undefined && video != video_last) {";
6. {
7. js += "video_last = video;";
8. js += "function video_start() {";
9. {
10. js += "_VideoEnabledWebView.notifyVideoStart();";
11. }
12. js += "}";
13. js += "video.addEventListener('play', video_start);";
14. }
15. js += "}";
16. main_wv.loadUrl(js); // main_wv为WebView控件

        忘了介绍，该js脚本在什么时候执行了。这里补充一下，为了使得页面自动播放视频，需要重写一个WebViewClient类，类名可以随你定义，比如“MyWebViewClient”，然后重写public void onPageFinished(WebView view, String url)方法，如下：

1. @Override
2. public void onPageFinished(WebView view, String url) {
3. super.onPageFinished(view, url);
4. String js = "javascript:";
5. js += "var videos = document.getElementsByTagName('video');";
6. js += "var video_last;";
7. js += "var video = videos[videos.length-1];";
8. js += "if (video != undefined && video != video_last) {";
9. {
10. js += "video_last = video;";
11. js += "function video_start() {";
12. {
13. js += "_VideoEnabledWebView.notifyVideoStart();";
14. }
15. js += "}";
16. js += "video.addEventListener('play', video_start);";
17. }
18. js += "}";
19. main_wv.loadUrl(js); // main_wv为WebView控件
20. }

        至此，还请记得改

main_wv.setWebViewClient(new WebViewClient()); // main_wv为WebView控件

        为

main_wv.setWebViewClient(new MyWebViewClient()); // main_wv为WebView控件

        这样，在访问网页时，视频就可以自动播放啦。

三、网页自动全屏思路

        网页全屏的实现思路比较复杂，因为Android开发者的初衷是使网页设计者无法通过js的方式直接全屏地播放视频。也就是说，通过js注入的方式无法直接在WebView中实现网页的全屏播放。为什么呢？根据其他人的说法，这是因为Android开发者担心你的手机不小心访问到一个流氓网页，然后该网页直接全屏，使你的手机失控，被它播放的视频霸占许久、不能退出。我想了想，觉得这个理由倒是有些许合理的。因此执行js脚本注入无法直接在WebView中实现网页视频的全屏播放。

        但是网页全屏的实现是完全没有问题的。大体的思路是：重写WebChromeClient和WebView这两个类，通过重写其中的内部方法，在加载完网页后，再调用js脚本注入，进而触发视频的全屏播放。而触发视频的全屏播放的js脚本为：

1. "javascript:(" +
2. "function() { " +
3. " var videos = document.getElementsByTagName('video'); " +
4. " var video = videos[0]; " +
5. " if (!document.webkitFullScreen && video.webkitEnterFullscreen) {" +
6. " video.webkitEnterFullscreen(); " +
7. " } " +
8. " })()"

        由于实现的细节很多，再加上我只是简单地研究了一下，所以没法更详细地展开说说了。请大家看后边“全部代码”的章节部分，了解更多细节。

四、手机默认横屏思路

        手机默认横屏的思路实现起来非常简单，简单得不得了，只需要在Manifest.xml这个清单文件中对指定的Activity声明相关的属性即可。例如，用于播放的Activity为MainActivity，那么就这样设置：

1. <activity android:name=".MainActivity"
2. android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
3. android:screenOrientation="landscape"
4. android:configChanges="orientation|screenSize|keyboardHidden"
5. android:hardwareAccelerated="true">
6. activity>

        其中，最关键的两行代码为

1. android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
2. android:screenOrientation="landscape"

        上面一行说的是让app在手机上运行时不显示标题栏(这个可以看你个人需求，有的人喜欢留着，有的人喜欢去掉)，而下面一行则是实现横屏的开关，landscape指的是风景，意为通过手机横屏的方式欣赏图片中的风景，以尽可能地使你更加清楚地目睹一张横向的风景图。

五、全部代码

        项目的代码目录，其中画横线部分是重点，我从创建项目到生成可运行且有效果的App只改动过这些文件。下面我将每个框中的文件中的代码罗列出来。

        AndroidManifest.xml

1. <?xml version="1.0" encoding="utf-8"?>
2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
3. package="***.***.******">
4. <uses-permission android:name="android.permission.INTERNET" />
5. <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
7. <application
8. android:allowBackup="true"
9. android:icon="@mipmap/ic_launcher"
10. android:label="@string/app_name"
11. android:roundIcon="@mipmap/ic_launcher_round"
12. android:supportsRtl="true"
13. android:theme="@style/AppTheme">
14. <activity android:name=".MainActivity"
15. android:hardwareAccelerated="true"
16. android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
17. android:screenOrientation="landscape">
18. <intent-filter>
19. <action android:name="android.intent.action.MAIN" />
20. <category android:name="android.intent.category.LAUNCHER" />
21. intent-filter>
22. activity>
23. application>
24. manifest>

        MainActivity.java

1. package ***.***.***;
3. import android.annotation.SuppressLint;
4. import android.app.Activity;
5. import android.content.Context;
6. import android.content.Intent;
7. import android.net.ConnectivityManager;
8. import android.net.NetworkInfo;
9. import android.os.Bundle;
10. import android.view.ViewGroup;
11. import android.webkit.WebSettings;
12. import android.webkit.WebView;
13. import android.webkit.WebViewClient;
14. import android.widget.LinearLayout;
15. import android.widget.RelativeLayout;
17. public class MainActivity extends Activity {
18. VideoEnabledWebView mainWebView;
19. RelativeLayout mainNonVideoRelativeLayout;
20. ViewGroup mainVideoLayout;
22. @Override
23. protected void onCreate(Bundle savedInstanceState) {
24. super.onCreate(savedInstanceState);
25. initView(); // initialize ui components
26. setWebView(); // set webview's settings
27. loadVideoUrl(); // load video url
28. }
30. private void initView() {
31. setContentView(R.layout.activity_main);
32. mainNonVideoRelativeLayout = (RelativeLayout) findViewById(R.id.main_rl_non_video);
33. mainVideoLayout = (ViewGroup)findViewById(R.id.main_rl_video);
34. }
36. @SuppressLint("SetJavaScriptEnabled")
37. private void setWebView() {
38. // create a webview instance
39. mainWebView = new VideoEnabledWebView(this);
40. mainWebView.setLayoutParams(new LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
42. // add the webview instance to the main layout
43. mainNonVideoRelativeLayout.addView(mainWebView);
45. // set general settings of webview
46. WebSettings settings = mainWebView.getSettings();
47. settings.setAllowFileAccess(true);
48. settings.setBuiltInZoomControls(false);
49. settings.setJavaScriptEnabled(true);
50. settings.setBuiltInZoomControls(false);
52. // create a WebChromeClient instance and use it to set the webview
53. VideoEnabledWebChromeClient videoEnabledWebChromeClient = new VideoEnabledWebChromeClient(mainNonVideoRelativeLayout, mainVideoLayout,null, mainWebView);
54. mainWebView.setWebChromeClient(videoEnabledWebChromeClient);
56. // create a WebViewClient for webview
57. mainWebView.setWebViewClient(new WebViewClient(){
58. @Override
59. public void onPageFinished(WebView view, String url) {
60. super.onPageFinished(view, url);
61. // execute a javascript to automatically play the video
62. String js = "javascript:";
63. js += "var videos = document.getElementsByTagName('video');";
64. js += "var video_last;";
65. js += "var video = videos[videos.length-1];";
66. js += "if (video != undefined && video != video_last) {";
67. {
68. js += "video_last = video;";
69. js += "function video_start() {";
70. {
71. js += "_VideoEnabledWebView.notifyVideoStart();";
72. }
73. js += "}";
74. js += "video.addEventListener('play', video_start);";
75. }
76. js += "}";
77. mainWebView.loadUrl(js);
78. }
79. });
80. }
82. private void loadVideoUrl() {
83. mainWebView.loadUrl("https://******"); // your url that contains the video
84. }
85. }

        activity_main.xml

1. <?xml version="1.0" encoding="utf-8"?>
2. <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
3. xmlns:tools="http://schemas.android.com/tools"
4. android:layout_width="match_parent"
5. android:layout_height="match_parent"
6. tools:context=".MainActivity">
7. <RelativeLayout
8. android:id="@+id/main_rl_non_video"
9. android:layout_width="match_parent"
10. android:layout_height="match_parent" >
11. RelativeLayout>
12. <RelativeLayout
13. android:id="@+id/main_rl_video"
14. android:layout_width="match_parent"
15. android:layout_height="match_parent" >
16. RelativeLayout>
17. androidx.constraintlayout.widget.ConstraintLayout>

        VideoEnabledWebChromeClient.java

1. package ***.***.***;
3. import android.media.MediaPlayer;
4. import android.view.SurfaceView;
5. import android.view.View;
6. import android.view.ViewGroup;
7. import android.webkit.WebChromeClient;
8. import android.widget.FrameLayout;
10. public class VideoEnabledWebChromeClient extends WebChromeClient implements MediaPlayer.OnPreparedListener, MediaPlayer.OnCompletionListener, MediaPlayer.OnErrorListener {
11. public interface ToggledFullscreenCallback {
12. void toggledFullscreen(boolean fullscreen);
13. }
15. private View activityNonVideoView;
16. private ViewGroup activityVideoView;
17. private View loadingView;
18. private VideoEnabledWebView webView;
20. // Indicates if the video is being displayed using a custom view (typically full-screen)
21. private boolean isVideoFullscreen;
23. private FrameLayout videoViewContainer;
24. private CustomViewCallback videoViewCallback;
26. private ToggledFullscreenCallback toggledFullscreenCallback;
28. /**
29. * Never use this constructor alone.
30. * This constructor allows this class to be defined as an inline inner class in which the user can override methods
31. */
32. @SuppressWarnings("unused")
33. public VideoEnabledWebChromeClient() {
34. }
36. /**
37. * Builds a video enabled WebChromeClient.
38. * @param activityNonVideoView A View in the activity's layout that contains every other view that should be hidden when the video goes full-screen.
39. * @param activityVideoView A ViewGroup in the activity's layout that will display the video. Typically you would like this to fill the whole layout.
40. */
41. @SuppressWarnings("unused")
42. public VideoEnabledWebChromeClient(View activityNonVideoView, ViewGroup activityVideoView) {
43. this.activityNonVideoView = activityNonVideoView;
44. this.activityVideoView = activityVideoView;
45. this.loadingView = null;
46. this.webView = null;
47. this.isVideoFullscreen = false;
48. }
50. /**
51. * Builds a video enabled WebChromeClient.
52. * @param activityNonVideoView A View in the activity's layout that contains every other view that should be hidden when the video goes full-screen.
53. * @param activityVideoView A ViewGroup in the activity's layout that will display the video. Typically you would like this to fill the whole layout.
54. * @param loadingView A View to be shown while the video is loading (typically only used in API level <11). Must be already inflated and not attached to a parent view.
55. */
56. @SuppressWarnings("unused")
57. public VideoEnabledWebChromeClient(View activityNonVideoView, ViewGroup activityVideoView, View loadingView) {
58. this.activityNonVideoView = activityNonVideoView;
59. this.activityVideoView = activityVideoView;
60. this.loadingView = loadingView;
61. this.webView = null;
62. this.isVideoFullscreen = false;
63. }
65. /**
66. * Builds a video enabled WebChromeClient.
67. * @param activityNonVideoView A View in the activity's layout that contains every other view that should be hidden when the video goes full-screen.
68. * @param activityVideoView A ViewGroup in the activity's layout that will display the video. Typically you would like this to fill the whole layout.
69. * @param loadingView A View to be shown while the video is loading (typically only used in API level <11). Must be already inflated and not attached to a parent view.
70. * @param webView The owner VideoEnabledWebView. Passing it will enable the VideoEnabledWebChromeClient to detect the HTML5 video ended event and exit full-screen.
71. * Note: The web page must only contain one video tag in order for the HTML5 video ended event to work. This could be improved if needed (see Javascript code).
72. */
73. @SuppressWarnings("unused")
74. public VideoEnabledWebChromeClient(View activityNonVideoView, ViewGroup activityVideoView, View loadingView, VideoEnabledWebView webView) {
75. this.activityNonVideoView = activityNonVideoView;
76. this.activityVideoView = activityVideoView;
77. this.loadingView = loadingView;
78. this.webView = webView;
79. this.isVideoFullscreen = false;
80. }
82. /**
83. * Indicates if the video is being displayed using a custom view (typically full-screen)
84. * @return true it the video is being displayed using a custom view (typically full-screen)
85. */
86. public boolean isVideoFullscreen() {
87. return isVideoFullscreen;
88. }
90. /**
91. * Set a callback that will be fired when the video starts or finishes displaying using a custom view (typically full-screen)
92. * @param callback A VideoEnabledWebChromeClient.ToggledFullscreenCallback callback
93. */
94. @SuppressWarnings("unused")
95. public void setOnToggledFullscreen(ToggledFullscreenCallback callback) {
96. this.toggledFullscreenCallback = callback;
97. }
99. @Override
100. public void onShowCustomView(View view, CustomViewCallback callback) {
101. if (view instanceof FrameLayout) {
102. // A video wants to be shown
103. FrameLayout frameLayout = (FrameLayout) view;
104. View focusedChild = frameLayout.getFocusedChild();
106. // Save video related variables
107. this.isVideoFullscreen = true;
108. this.videoViewContainer = frameLayout;
109. this.videoViewCallback = callback;
111. // Hide the non-video view, add the video view, and show it
112. activityNonVideoView.setVisibility(View.INVISIBLE);
113. activityVideoView.addView(videoViewContainer, new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
114. activityVideoView.setVisibility(View.VISIBLE);
116. if (focusedChild instanceof android.widget.VideoView) {
117. // android.widget.VideoView (typically API level <11)
118. android.widget.VideoView videoView = (android.widget.VideoView) focusedChild;
120. // Handle all the required events
121. videoView.setOnPreparedListener(this);
122. videoView.setOnCompletionListener(this);
123. videoView.setOnErrorListener(this);
124. } else {
125. // Other classes, including:
126. // - android.webkit.HTML5VideoFullScreen$VideoSurfaceView, which inherits from android.view.SurfaceView (typically API level 11-18)
127. // - android.webkit.HTML5VideoFullScreen$VideoTextureView, which inherits from android.view.TextureView (typically API level 11-18)
128. // - com.android.org.chromium.content.browser.ContentVideoView$VideoSurfaceView, which inherits from android.view.SurfaceView (typically API level 19+)
129. // Handle HTML5 video ended event only if the class is a SurfaceView
130. // Test case: TextureView of Sony Xperia T API level 16 doesn't work fullscreen when loading the javascript below
131. if (webView != null && webView.getSettings().getJavaScriptEnabled() && focusedChild instanceof SurfaceView) {
132. // Run javascript code that detects the video end and notifies the Javascript interface
133. String js = "javascript:";
134. js += "var _ytrp_html5_video_last;";
135. js += "var _ytrp_html5_video = document.getElementsByTagName('video')[0];";
136. js += "if (_ytrp_html5_video != undefined && _ytrp_html5_video != _ytrp_html5_video_last) {";
137. {
138. js += "_ytrp_html5_video_last = _ytrp_html5_video;";
139. js += "function _ytrp_html5_video_ended() {";
140. {
141. js += "_VideoEnabledWebView.notifyVideoEnd();"; // Must match Javascript interface name and method of VideoEnableWebView
142. }
143. js += "}";
144. js += "_ytrp_html5_video.addEventListener('ended', _ytrp_html5_video_ended);";
145. }
146. js += "}";
147. webView.loadUrl(js);
148. }
149. }
151. // Notify full-screen change
152. if (toggledFullscreenCallback != null) {
153. toggledFullscreenCallback.toggledFullscreen(true);
154. }
155. }
156. }
158. @Override
159. // Available in API level 14+, deprecated in API level 18+
160. public void onShowCustomView(View view, int requestedOrientation, CustomViewCallback callback) {
161. onShowCustomView(view, callback);
162. }
164. @Override
165. // This method should be manually called on video end in all cases because it's not always called automatically.
166. // This method must be manually called on back key press (from this class' onBackPressed() method).
167. public void onHideCustomView() {
168. if (isVideoFullscreen) {
169. // Hide the video view, remove it, and show the non-video view
170. activityVideoView.setVisibility(View.INVISIBLE);
171. activityVideoView.removeView(videoViewContainer);
172. activityNonVideoView.setVisibility(View.VISIBLE);
174. // Call back (only in API level <19, because in API level 19+ with chromium webview it crashes)
175. if (videoViewCallback != null && !videoViewCallback.getClass().getName().contains(".chromium.")) {
176. videoViewCallback.onCustomViewHidden();
177. }
179. // Reset video related variables
180. isVideoFullscreen = false;
181. videoViewContainer = null;
182. videoViewCallback = null;
184. // Notify full-screen change
185. if (toggledFullscreenCallback != null) {
186. toggledFullscreenCallback.toggledFullscreen(false);
187. }
188. }
189. }
191. @Override
192. // Video will start loading
193. public View getVideoLoadingProgressView() {
194. if (loadingView != null) {
195. loadingView.setVisibility(View.VISIBLE);
196. return loadingView;
197. } else {
198. return super.getVideoLoadingProgressView();
199. }
200. }
202. @Override
203. // Video will start playing, only called in the case of android.widget.VideoView (typically API level <11)
204. public void onPrepared(MediaPlayer mp) {
205. if (loadingView != null) {
206. loadingView.setVisibility(View.GONE);
207. }
208. }
210. @Override
211. // Video finished playing, only called in the case of android.widget.VideoView (typically API level <11)
212. public void onCompletion(MediaPlayer mp) {
213. onHideCustomView();
214. }
216. @Override
217. // Error while playing video, only called in the case of android.widget.VideoView (typically API level <11)
218. public boolean onError(MediaPlayer mp, int what, int extra) {
219. return false; // By returning false, onCompletion() will be called
220. }
222. /**
223. * Notifies the class that the back key has been pressed by the user.
224. * This must be called from the Activity's onBackPressed(), and if it returns false, the activity itself should handle it. Otherwise don't do anything.
225. * @return Returns true if the event was handled, and false if was not (video view is not visible)
226. */
227. @SuppressWarnings("unused")
228. public boolean onBackPressed() {
229. if (isVideoFullscreen) {
230. onHideCustomView();
231. return true;
232. } else {
233. return false;
234. }
235. }
236. }

        VideoEnabledWebView.java

1. package ***.***.***;
3. import android.annotation.SuppressLint;
4. import android.content.Context;
5. import android.os.Handler;
6. import android.os.Looper;
7. import android.util.AttributeSet;
8. import android.webkit.WebChromeClient;
9. import android.webkit.WebView;
11. import java.util.Map;
13. public class VideoEnabledWebView extends WebView {
14. public class JavascriptInterface {
15. @android.webkit.JavascriptInterface
16. @SuppressWarnings("unused")
17. // Must match Javascript interface method of VideoEnabledWebChromeClient
18. public void notifyVideoEnd() {
19. // This code is not executed in the UI thread, so we must force that to happen
20. new Handler(Looper.getMainLooper()).post(new Runnable() {
21. @Override
22. public void run() {
23. if (videoEnabledWebChromeClient != null) {
24. videoEnabledWebChromeClient.onHideCustomView();
25. }
26. }
27. });
28. }
30. @android.webkit.JavascriptInterface
31. @SuppressWarnings("unused")
32. // Must match Javascript interface method of VideoEnabledWebChromeClient
33. public void notifyVideoStart() {
34. // This code is not executed in the UI thread, so we must force that to happen
35. new Handler(Looper.getMainLooper()).post(new Runnable() {
36. @Override
37. public void run() {
38. loadUrl("javascript:(" +
39. "function() { " +
40. " var videos = document.getElementsByTagName('video'); " +
41. " var video = videos[0]; " +
42. " if (!document.webkitFullScreen && video.webkitEnterFullscreen) {" +
43. " video.webkitEnterFullscreen(); " +
44. " } " +
45. " })()");
46. }
47. });
48. }
49. }
51. private VideoEnabledWebChromeClient videoEnabledWebChromeClient;
52. private boolean addedJavascriptInterface;
54. @SuppressWarnings("unused")
55. public VideoEnabledWebView(Context context) {
56. super(context);
57. addedJavascriptInterface = false;
58. }
60. @SuppressWarnings("unused")
61. public VideoEnabledWebView(Context context, AttributeSet attrs) {
62. super(context, attrs);
63. addedJavascriptInterface = false;
64. }
66. @SuppressWarnings("unused")
67. public VideoEnabledWebView(Context context, AttributeSet attrs, int defStyle) {
68. super(context, attrs, defStyle);
69. addedJavascriptInterface = false;
70. }
72. /**
73. * Indicates if the video is being displayed using a custom view (typically full-screen)
74. *
75. * @return true it the video is being displayed using a custom view (typically full-screen)
76. */
77. @SuppressWarnings("unused")
78. public boolean isVideoFullscreen() {
79. return videoEnabledWebChromeClient != null && videoEnabledWebChromeClient.isVideoFullscreen();
80. }
82. /**
83. * Pass only a VideoEnabledWebChromeClient instance.
84. */
85. @Override
86. @SuppressLint("SetJavaScriptEnabled")
87. public void setWebChromeClient(WebChromeClient client) {
88. getSettings().setJavaScriptEnabled(true);
89. if (client instanceof VideoEnabledWebChromeClient) {
90. this.videoEnabledWebChromeClient = (VideoEnabledWebChromeClient) client;
91. }
92. super.setWebChromeClient(client);
93. }
95. @Override
96. public void loadData(String data, String mimeType, String encoding) {
97. addJavascriptInterface();
98. super.loadData(data, mimeType, encoding);
99. }
101. @Override
102. public void loadDataWithBaseURL(String baseUrl, String data, String mimeType, String encoding, String historyUrl) {
103. addJavascriptInterface();
104. super.loadDataWithBaseURL(baseUrl, data, mimeType, encoding, historyUrl);
105. }
107. @Override
108. public void loadUrl(String url) {
109. super.loadUrl(url);
110. addJavascriptInterface();
111. }
113. @Override
114. public void loadUrl(String url, Map additionalHttpHeaders) {
115. addJavascriptInterface();
116. super.loadUrl(url, additionalHttpHeaders);
117. }
119. @SuppressLint("AddJavascriptInterface")
120. private void addJavascriptInterface() {
121. if (!addedJavascriptInterface) {
122. // Add javascript interface to be called when the video ends (must be done before page load)
123. // Must match Javascript interface name of VideoEnabledWebChromeClient
124. addJavascriptInterface(new JavascriptInterface(), "_VideoEnabledWebView");
125. addedJavascriptInterface = true;
126. }
127. }
128. }

六、效果

        打开App之后，经过2s的时间(对于个人而言，2s是可接受的等待时间)直接视频全屏播放

        但我发现url有时候不是特别稳定，所以有时候看不了，并建议使用电脑端访问。

七、参考资料

1.如何在android WebView中全屏播放HTML5视频？

2.android webview播放视频自动全屏

八、声明

上述代码仅限个人的学习使用，请勿用于商业用途，请勿非法使用，谢谢。