├── .gitignore
├── LICENSE
├── README.md
├── VLCPlayer.js
├── android
    ├── build.gradle
    ├── proguard-rules.pro
    └── src
    │   └── main
    │       ├── AndroidManifest.xml
    │       ├── java
    │           └── com
    │           │   └── lunarr
    │           │       └── vlc
    │           │           ├── ReactVlcPlayerPackage.java
    │           │           └── vlcplayer
    │           │               ├── ReactVlcPlayerView.java
    │           │               ├── ReactVlcPlayerViewManager.java
    │           │               └── VideoEventEmitter.java
    │       └── res
    │           └── values
    │               └── strings.xml
├── index.js
├── ios
    ├── RCTVLCPlayer.xcodeproj
    │   └── project.pbxproj
    └── RCTVLCPlayer
    │   ├── RCTVLCPlayer.h
    │   ├── RCTVLCPlayer.m
    │   ├── RCTVLCPlayerManager.h
    │   └── RCTVLCPlayerManager.m
├── package.json
├── react-native-vlc-player.podspec
└── yarn.lock


/.gitignore:
--------------------------------------------------------------------------------
  1 | # Xcode
  2 | !**/*.xcodeproj
  3 | !**/*.pbxproj
  4 | !**/*.xcworkspacedata
  5 | !**/*.xcsettings
  6 | !**/*.xcscheme
  7 | *.pbxuser
  8 | !default.pbxuser
  9 | *.mode1v3
 10 | !default.mode1v3
 11 | *.mode2v3
 12 | !default.mode2v3
 13 | *.perspectivev3
 14 | !default.perspectivev3
 15 | xcuserdata
 16 | *.xccheckout
 17 | *.moved-aside
 18 | DerivedData
 19 | *.hmap
 20 | *.ipa
 21 | *.xcuserstate
 22 | project.xcworkspace
 23 | 
 24 | # Gradle
 25 | /build/
 26 | /RNTester/android/app/build/
 27 | /RNTester/android/app/gradle/
 28 | /RNTester/android/app/gradlew
 29 | /RNTester/android/app/gradlew.bat
 30 | /ReactAndroid/build/
 31 | /ReactAndroid/gradle/
 32 | /ReactAndroid/gradlew
 33 | /ReactAndroid/gradlew.bat
 34 | 
 35 | # Buck
 36 | .buckd
 37 | buck-out
 38 | /ReactAndroid/src/main/jni/prebuilt/lib/
 39 | /ReactAndroid/src/main/gen
 40 | 
 41 | # Android Studio
 42 | .project
 43 | .settings
 44 | .classpath
 45 | 
 46 | # Watchman
 47 | .watchmanconfig
 48 | 
 49 | # Android
 50 | .idea
 51 | .gradle
 52 | local.properties
 53 | *.iml
 54 | 
 55 | # Node
 56 | node_modules
 57 | *.log
 58 | .nvm
 59 | /bots/node_modules/
 60 | package-lock.json
 61 | 
 62 | # OS X
 63 | .DS_Store
 64 | 
 65 | # Test generated files
 66 | /ReactAndroid/src/androidTest/assets/AndroidTestBundle.js
 67 | *.js.meta
 68 | 
 69 | /coverage
 70 | /third-party
 71 | 
 72 | # Root dir shouldn't have Xcode project
 73 | /*.xcodeproj
 74 | 
 75 | # ReactCommon subdir shouldn't have Xcode project
 76 | /ReactCommon/**/*.xcodeproj
 77 | RNTester/build
 78 | 
 79 | # Libs that shouldn't have Xcode project
 80 | /Libraries/FBLazyVector/**/*.xcodeproj
 81 | /Libraries/FBReactNativeSpec/**/*.xcodeproj
 82 | /Libraries/RCTRequired/**/*.xcodeproj
 83 | /React/CoreModules/**/*.xcodeproj
 84 | /packages/react-native-codegen/**/*.xcodeproj
 85 | 
 86 | # CocoaPods
 87 | /template/ios/Pods/
 88 | /template/ios/Podfile.lock
 89 | /RNTester/Gemfile.lock
 90 | 
 91 | # Ignore RNTester specific Pods, but keep the __offline_mirrors__ here.
 92 | RNTester/Pods/*
 93 | !RNTester/Pods/__offline_mirrors
 94 | 
 95 | # react-native-codegen
 96 | /ReactCommon/fabric/components/rncore/
 97 | /schema-rncore.json
 98 | 
 99 | # Visual studio
100 | .vscode
101 | .vs
102 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2016 Brent Vatne, Baris Sencan
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## @lunarr/vlc-player
 2 | 
 3 | VLC Player for react-native based on `xuyuanzhou/react-native-yz-vlcplayer`, `delia-m/react-native-yz-vlcplayer` and `react-native-vlc-media-player` to be used on Lunarr.
 4 | 
 5 | ## Installation
 6 | 
 7 | #### React Native 0.60+
 8 | 
 9 | `yarn add @lunarr/vlc-player`
10 | 
11 | #### Additional step for iOS
12 | 
13 | Set `Enable Bitcode` to `NO`
14 | 
15 | Build Settings ---> search Bitcode
16 | 
17 | ![disable bitcode](https://raw.githubusercontent.com/xuyuanzhou/react-native-yz-vlcplayer/master/images/4.png)
18 | 
19 | Don't forget to `pod update` and `gradlew clean`
20 | 
21 | ## Example
22 | 
23 | ```js
24 | import Video from "@lunarr/vlc-player";
25 | 
26 | <Video
27 |   ref={videoRef}
28 |   source={{ uri: url }}
29 |   style={styles.video}
30 |   onProgress={({ currentTime, duration }) => {
31 |     setState({
32 |       currentTime, // seconds
33 |       duration // seconds
34 |     });
35 |   }}
36 |   onSeek={({ currentTime, duration }) => {
37 |     setState({
38 |       currentTime, // seconds
39 |       duration // seconds
40 |     });
41 |   }}
42 |   onEnd={() => {
43 |     setState({ play: false });
44 |   }}
45 |   onError={() => {
46 |     setState({
47 |       play: false,
48 |       error: {
49 |         error: "Oops!",
50 |         message:
51 |           "There was an error playing this video, please try again later."
52 |       }
53 |     });
54 |   }}
55 |   paused={!state.play}
56 | />
57 | ```
58 | 


--------------------------------------------------------------------------------
/VLCPlayer.js:
--------------------------------------------------------------------------------
1 | import { requireNativeComponent } from "react-native";
2 | 
3 | const VLCPlayer = requireNativeComponent("RCTVLCPlayer");
4 | 
5 | export default VLCPlayer;
6 | 


--------------------------------------------------------------------------------
/android/build.gradle:
--------------------------------------------------------------------------------
 1 | apply plugin: 'com.android.library'
 2 | 
 3 | def safeExtGet(prop, fallback) {
 4 |     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 5 | }
 6 | 
 7 | android {
 8 |     compileSdkVersion safeExtGet('compileSdkVersion', 29)
 9 |     buildToolsVersion safeExtGet('buildToolsVersion', '29.0.3')
10 | 
11 |     defaultConfig {
12 |         minSdkVersion 17
13 |         targetSdkVersion safeExtGet("targetSdkVersion", 29)
14 |         versionCode 1
15 |         versionName "1.0"
16 |         ndk {
17 |             // Supported abi (optional streamlined library)
18 |             abiFilters 'armeabi-v7a'//,'x86_64','arm64-v8a','x86'
19 |         }
20 |     }
21 |     buildTypes {
22 |         release {
23 |             minifyEnabled false
24 |             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
25 |         }
26 |     }
27 | }
28 | 
29 | repositories {
30 |     maven { url 'https://dl.bintray.com/videolan/Android' }
31 | }
32 | 
33 | dependencies {
34 |     implementation fileTree(dir: 'libs', include: ['*.jar'])
35 |     implementation 'com.facebook.react:react-native:+'
36 |     implementation 'org.videolan.android:libvlc-all:3.2.6'
37 |     implementation 'androidx.appcompat:appcompat:1.2.0'
38 | }
39 | 


--------------------------------------------------------------------------------
/android/proguard-rules.pro:
--------------------------------------------------------------------------------
 1 | # Add project specific ProGuard rules here.
 2 | # By default, the flags in this file are appended to flags specified
 3 | # in /Users/aolc/Library/Android/sdk/tools/proguard/proguard-android.txt
 4 | # You can edit the include path and order by changing the proguardFiles
 5 | # directive in build.gradle.
 6 | #
 7 | # For more details, see
 8 | #   http://developer.android.com/guide/developing/tools/proguard.html
 9 | 
10 | # Add any project specific keep options here:
11 | 
12 | # If your project uses WebView with JS, uncomment the following
13 | # and specify the fully qualified class name to the JavaScript interface
14 | # class:
15 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
16 | #   public *;
17 | #}
18 | 
19 | # Uncomment this to preserve the line number information for
20 | # debugging stack traces.
21 | #-keepattributes SourceFile,LineNumberTable
22 | 
23 | # If you keep the line number information, uncomment this to
24 | # hide the original source file name.
25 | #-renamesourcefileattribute SourceFile
26 | 


--------------------------------------------------------------------------------
/android/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 | <manifest xmlns:android="http://schemas.android.com/apk/res/android"
2 |     package="com.lunarr.vlc">
3 | 
4 |     <application  android:label="@string/app_name"
5 |         android:supportsRtl="true">
6 |     </application>
7 | </manifest>
8 | 


--------------------------------------------------------------------------------
/android/src/main/java/com/lunarr/vlc/ReactVlcPlayerPackage.java:
--------------------------------------------------------------------------------
 1 | package com.lunarr.vlc;
 2 | 
 3 | import com.facebook.react.ReactPackage;
 4 | import com.facebook.react.bridge.JavaScriptModule;
 5 | import com.facebook.react.bridge.NativeModule;
 6 | import com.facebook.react.bridge.ReactApplicationContext;
 7 | import com.facebook.react.uimanager.ViewManager;
 8 | 
 9 | import java.util.Collections;
10 | import java.util.List;
11 | 
12 | import com.lunarr.vlc.vlcplayer.ReactVlcPlayerViewManager;
13 | 
14 | public class ReactVlcPlayerPackage implements ReactPackage {
15 | 
16 |     @Override
17 |     public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
18 |         return Collections.emptyList();
19 |     }
20 | 
21 |     // Deprecated RN 0.47
22 |     public List<Class<? extends JavaScriptModule>> createJSModules() {
23 |         return Collections.emptyList();
24 |     }
25 | 
26 |     @Override
27 |     public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
28 |         return Collections.<ViewManager>singletonList(new ReactVlcPlayerViewManager());
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/android/src/main/java/com/lunarr/vlc/vlcplayer/ReactVlcPlayerView.java:
--------------------------------------------------------------------------------
  1 | package com.lunarr.vlc.vlcplayer;
  2 | 
  3 | import android.annotation.SuppressLint;
  4 | import android.content.Context;
  5 | import android.graphics.Color;
  6 | import android.graphics.PixelFormat;
  7 | import android.graphics.SurfaceTexture;
  8 | import android.media.AudioManager;
  9 | import android.net.Uri;
 10 | import android.os.Handler;
 11 | import android.util.DisplayMetrics;
 12 | import android.util.Log;
 13 | import android.view.Surface;
 14 | import android.view.SurfaceHolder;
 15 | import android.view.SurfaceView;
 16 | import android.view.TextureView;
 17 | import android.view.View;
 18 | 
 19 | import com.facebook.react.bridge.Arguments;
 20 | import com.facebook.react.bridge.LifecycleEventListener;
 21 | import com.facebook.react.bridge.ReadableArray;
 22 | import com.facebook.react.bridge.ReadableMap;
 23 | import com.facebook.react.bridge.WritableMap;
 24 | import com.facebook.react.uimanager.ThemedReactContext;
 25 | 
 26 | import org.videolan.libvlc.IVLCVout;
 27 | import org.videolan.libvlc.LibVLC;
 28 | import org.videolan.libvlc.Media;
 29 | import org.videolan.libvlc.MediaPlayer;
 30 | import java.util.ArrayList;
 31 | 
 32 | @SuppressLint("ViewConstructor")
 33 | class ReactVlcPlayerView extends TextureView implements
 34 |         LifecycleEventListener,
 35 |         TextureView.SurfaceTextureListener,
 36 |         AudioManager.OnAudioFocusChangeListener{
 37 | 
 38 |     private static final String TAG = "ReactVlcPlayerView";
 39 |     private final String tag = "ReactVlcPlayerView";
 40 | 
 41 |     private final VideoEventEmitter eventEmitter;
 42 |     private LibVLC libvlc;
 43 |     private MediaPlayer mMediaPlayer = null;
 44 |     private TextureView surfaceView;
 45 |     private Surface surfaceVideo;//视频画布
 46 |     private boolean isSurfaceViewDestory;
 47 |     private int surfaceW, surfaceH;
 48 |     //资源路径
 49 |     private String src;
 50 |     //是否网络资源
 51 |     private  boolean netStrTag;
 52 |     private ReadableMap srcMap;
 53 | 
 54 | 
 55 |     //private Handler mainHandler;
 56 |    /* private static final int SURFACE_BEST_FIT = 0;
 57 |     private static final int SURFACE_FIT_HORIZONTAL = 1;
 58 |     private static final int SURFACE_FIT_VERTICAL = 2;
 59 |     private static final int SURFACE_FILL = 3;
 60 |     private static final int SURFACE_16_9 = 4;
 61 |     private static final int SURFACE_4_3 = 5;
 62 |     private static final int SURFACE_ORIGINAL = 6;
 63 |     private int mCurrentSize = SURFACE_BEST_FIT;*/
 64 |     // Props from React
 65 |     /* private Uri srcUri;
 66 |     private String extension;
 67 |     private boolean repeat;
 68 |     private boolean disableFocus;
 69 |     private boolean playInBackground = false;*/
 70 |     // \ End props
 71 | 
 72 |     private int mVideoHeight = 0;
 73 |     private int mVideoWidth = 0;
 74 |     private int mVideoVisibleHeight = 0;
 75 |     private int mVideoVisibleWidth = 0;
 76 |     private int mSarNum = 0;
 77 |     private int mSarDen = 0;
 78 |     private int screenWidth = 0;
 79 |     private int screenHeight = 0;
 80 |     private boolean isPaused = true;
 81 |     private boolean isHostPaused = false;
 82 |     private int preVolume = 100;
 83 |     private boolean autoAspectRatio = false;
 84 | 
 85 |     // React
 86 |     private final ThemedReactContext themedReactContext;
 87 |     private final AudioManager audioManager;
 88 | 
 89 | 
 90 | 
 91 | 
 92 |     public ReactVlcPlayerView(ThemedReactContext context) {
 93 |         super(context);
 94 |         this.eventEmitter = new VideoEventEmitter(context);
 95 |         this.themedReactContext = context;
 96 |         audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
 97 |         //themedReactContext.addLifecycleEventListener(this);
 98 |         DisplayMetrics dm = getResources().getDisplayMetrics();
 99 |         screenHeight = dm.heightPixels;
100 |         screenWidth = dm.widthPixels;
101 |         this.setSurfaceTextureListener(this);
102 |         //surfaceView = this;
103 |         //surfaceView.setZOrderOnTop(false);
104 |         //surfaceView.setZOrderMediaOverlay(false);
105 |        // this.setZOrderOnTop(true);
106 |        // this.getHolder().setFormat(PixelFormat.TRANSLUCENT);
107 |         //this.setEGLConfigChooser(8, 8, 8, 8, 16, 0);
108 |        //this.setZOrderMediaOverlay(true);
109 |         //
110 |         //不过中间那句是OpenGl的，视情况使用，无用可注释掉了，也能实现了透明，但是GLSurfaceView就必须使用
111 | 
112 |        // this.setZOrderMediaOverlay(false);
113 |         this.addOnLayoutChangeListener(onLayoutChangeListener);
114 |     }
115 | 
116 | 
117 |     @Override
118 |     public void setId(int id) {
119 |         super.setId(id);
120 |         eventEmitter.setViewId(id);
121 |     }
122 | 
123 |     @Override
124 |     protected void onAttachedToWindow() {
125 |         super.onAttachedToWindow();
126 |         //createPlayer();
127 |     }
128 | 
129 |     @Override
130 |     protected void onDetachedFromWindow() {
131 |         super.onDetachedFromWindow();
132 |         stopPlayback();
133 |     }
134 | 
135 |     // LifecycleEventListener implementation
136 | 
137 |     @Override
138 |     public void onHostResume() {
139 |         if(mMediaPlayer != null && isSurfaceViewDestory && isHostPaused){
140 |             IVLCVout vlcOut =  mMediaPlayer.getVLCVout();
141 |             if(!vlcOut.areViewsAttached()){
142 |                // vlcOut.setVideoSurface(this.getHolder().getSurface(), this.getHolder());
143 |                 vlcOut.attachViews(onNewVideoLayoutListener);
144 |                 isSurfaceViewDestory = false;
145 |                 isPaused = false;
146 |                // this.getHolder().setKeepScreenOn(true);
147 |                 mMediaPlayer.play();
148 |             }
149 |         }
150 |     }
151 | 
152 | 
153 |     @Override
154 |     public void onHostPause() {
155 |         if(!isPaused && mMediaPlayer != null){
156 |             isPaused = true;
157 |             isHostPaused = true;
158 |             mMediaPlayer.pause();
159 |            // this.getHolder().setKeepScreenOn(false);
160 |             WritableMap map = Arguments.createMap();
161 |             map.putString("type","Paused");
162 |             eventEmitter.onVideoStateChange(map);
163 |         }
164 |         Log.i("onHostPause","---------onHostPause------------>");
165 |     }
166 | 
167 | 
168 | 
169 |     @Override
170 |     public void onHostDestroy() {
171 |         stopPlayback();
172 |     }
173 | 
174 | 
175 |     // AudioManager.OnAudioFocusChangeListener implementation
176 |     @Override
177 |     public void onAudioFocusChange(int focusChange) {
178 |     }
179 | 
180 | 
181 |     /*************
182 |      * Events  Listener
183 |      *************/
184 | 
185 |     private View.OnLayoutChangeListener onLayoutChangeListener = new View.OnLayoutChangeListener(){
186 | 
187 |         @Override
188 |         public void onLayoutChange(View view, int i, int i1, int i2, int i3, int i4, int i5, int i6, int i7) {
189 |             if(view.getWidth() > 0 && view.getHeight() > 0 ){
190 |                 mVideoWidth = view.getWidth(); // 获取宽度
191 |                 mVideoHeight = view.getHeight(); // 获取高度
192 |                 if(mMediaPlayer != null) {
193 |                     IVLCVout vlcOut = mMediaPlayer.getVLCVout();
194 |                     vlcOut.setWindowSize(mVideoWidth, mVideoHeight);
195 |                     if(autoAspectRatio){
196 |                         mMediaPlayer.setAspectRatio(mVideoWidth + ":" + mVideoHeight);
197 |                     }
198 |                 }
199 |             }
200 |         }
201 |     };
202 | 
203 |     /**
204 |      * 播放过程中的时间事件监听
205 |      */
206 |     private MediaPlayer.EventListener mPlayerListener = new MediaPlayer.EventListener(){
207 |         @Override
208 |         public void onEvent(MediaPlayer.Event event) {
209 |             WritableMap map = Arguments.createMap();
210 |             // float position = mMediaPlayer.getPosition();
211 |             // map.putDouble("position",position);
212 |             switch (event.type) {
213 |               case MediaPlayer.Event.TimeChanged:
214 |                   map.putDouble("currentTime",mMediaPlayer.getTime());
215 |                   map.putDouble("duration",mMediaPlayer.getLength());
216 |                   eventEmitter.progressChanged(map);
217 |                   break;
218 |                 case MediaPlayer.Event.EndReached:
219 |                     map.putString("type","Ended");
220 |                     eventEmitter.onVideoStateChange(map);
221 |                     break;
222 |                 case MediaPlayer.Event.Playing:
223 |                     map.putString("type","Playing");
224 |                     eventEmitter.onVideoStateChange(map);
225 |                     break;
226 |                 case MediaPlayer.Event.Opening:
227 |                     map.putString("type","Opening");
228 |                     map.putDouble("currentTime",mMediaPlayer.getTime());
229 |                     map.putDouble("duration",mMediaPlayer.getLength());
230 |                     eventEmitter.onVideoStateChange(map);
231 |                     break;
232 |                 case MediaPlayer.Event.Paused:
233 |                     map.putString("type","Paused");
234 |                     eventEmitter.onVideoStateChange(map);
235 |                     break;
236 |                 case MediaPlayer.Event.Buffering:
237 |                     map.putDouble("bufferRate",event.getBuffering());
238 |                     map.putBoolean("isBuffering",!mMediaPlayer.isPlaying());
239 |                     map.putString("type","Buffering");
240 |                     eventEmitter.onVideoStateChange(map);
241 |                     break;
242 |                 case MediaPlayer.Event.Stopped:
243 |                     map.putString("type","Stopped");
244 |                     eventEmitter.onVideoStateChange(map);
245 |                     break;
246 |                 case MediaPlayer.Event.EncounteredError:
247 |                     map.putString("type","Error");
248 |                     eventEmitter.onVideoStateChange(map);
249 |                     break;
250 |             }
251 |         }
252 |     };
253 | 
254 |     private IVLCVout.OnNewVideoLayoutListener onNewVideoLayoutListener = new IVLCVout.OnNewVideoLayoutListener(){
255 |         @Override
256 |         public void onNewVideoLayout(IVLCVout vout, int width, int height, int visibleWidth, int visibleHeight, int sarNum, int sarDen) {
257 |             if (width * height == 0)
258 |                 return;
259 |             // store video size
260 |             mVideoWidth = width;
261 |             mVideoHeight = height;
262 |             mVideoVisibleWidth  = visibleWidth;
263 |             mVideoVisibleHeight = visibleHeight;
264 |             mSarNum = sarNum;
265 |             mSarDen = sarDen;
266 |             WritableMap map = Arguments.createMap();
267 |             map.putInt("mVideoWidth",mVideoWidth);
268 |             map.putInt("mVideoHeight",mVideoHeight);
269 |             map.putInt("mVideoVisibleWidth",mVideoVisibleWidth);
270 |             map.putInt("mVideoVisibleHeight",mVideoVisibleHeight);
271 |             map.putInt("mSarNum",mSarNum);
272 |             map.putInt("mSarDen",mSarDen);
273 |             map.putString("type","onNewVideoLayout");
274 |             eventEmitter.onVideoStateChange(map);
275 |         }
276 |     };
277 | 
278 |     IVLCVout.Callback callback = new IVLCVout.Callback() {
279 |         @Override
280 |         public void onSurfacesCreated(IVLCVout ivlcVout) {
281 |             isSurfaceViewDestory = false;
282 |         }
283 | 
284 |         @Override
285 |         public void onSurfacesDestroyed(IVLCVout ivlcVout) {
286 |             isSurfaceViewDestory = true;
287 |         }
288 | 
289 |     };
290 | 
291 | 
292 | 
293 |     /*************
294 |      * MediaPlayer
295 |      *************/
296 | 
297 | 
298 |     private void stopPlayback() {
299 |         onStopPlayback();
300 |         releasePlayer();
301 |     }
302 | 
303 |     private void onStopPlayback() {
304 |         // setKeepScreenOn(false);
305 |         audioManager.abandonAudioFocus(this);
306 |     }
307 | 
308 |     private void createPlayer(boolean autoplayResume, boolean isResume) {
309 |         releasePlayer();
310 |         if(this.getSurfaceTexture() == null){
311 |             return;
312 |         }
313 |         try {
314 |             final ArrayList<String> cOptions = new ArrayList<>();
315 |             String uriString = srcMap.hasKey("uri") ? srcMap.getString("uri") : null;
316 |             //String extension = srcMap.hasKey("type") ? srcMap.getString("type") : null;
317 |             boolean isNetwork = srcMap.hasKey("isNetwork") ? srcMap.getBoolean("isNetwork") : false;
318 |             boolean autoplay = srcMap.hasKey("autoplay") ? srcMap.getBoolean("autoplay") : true;
319 |             int initType =     srcMap.hasKey("initType") ? srcMap.getInt("initType") : 1;
320 |             ReadableArray mediaOptions =     srcMap.hasKey("mediaOptions") ? srcMap.getArray("mediaOptions") : null;
321 |             ReadableArray initOptions = srcMap.hasKey("initOptions") ? srcMap.getArray("initOptions") : null;
322 |             Integer hwDecoderEnabled = srcMap.hasKey("hwDecoderEnabled") ? srcMap.getInt("hwDecoderEnabled") : null;
323 |             Integer hwDecoderForced = srcMap.hasKey("hwDecoderForced") ? srcMap.getInt("hwDecoderForced") : null;
324 | 
325 |             if(initOptions != null){
326 |                 ArrayList options = initOptions.toArrayList();
327 |                 for(int i=0; i < options.size() - 1 ; i++){
328 |                     String option = (String)options.get(i);
329 |                     cOptions.add(option);
330 |                 }
331 |             }
332 |             // Create LibVLC
333 |             if(initType == 1){
334 |                 libvlc = new LibVLC(getContext());
335 |             }else{
336 |                 libvlc = new LibVLC(getContext(), cOptions);
337 |             }
338 |             // Create media player
339 |             mMediaPlayer = new MediaPlayer(libvlc);
340 |             mMediaPlayer.setEventListener(mPlayerListener);
341 |             //this.getHolder().setKeepScreenOn(true);
342 |             IVLCVout vlcOut =  mMediaPlayer.getVLCVout();
343 |             if(mVideoWidth > 0 && mVideoHeight > 0){
344 |                 vlcOut.setWindowSize(mVideoWidth,mVideoHeight);
345 |                 if(autoAspectRatio){
346 |                     mMediaPlayer.setAspectRatio(mVideoWidth + ":" + mVideoHeight);
347 |                 }
348 |                 //mMediaPlayer.setAspectRatio(mVideoWidth+":"+mVideoHeight);
349 |             }
350 |             DisplayMetrics dm = getResources().getDisplayMetrics();
351 |             Media m = null;
352 |             if(isNetwork){
353 |                 Uri uri = Uri.parse(uriString);
354 |                 m = new Media(libvlc, uri);
355 |             }else{
356 |                 m = new Media(libvlc, uriString);
357 |             }
358 |             // m.setEventListener(mMediaListener);
359 |             if(hwDecoderEnabled != null && hwDecoderForced != null){
360 |                 boolean hmEnabled = false;
361 |                 boolean hmForced  = false;
362 |                 if(hwDecoderEnabled >= 1){
363 |                     hmEnabled = true;
364 |                 }
365 |                 if(hwDecoderForced >= 1){
366 |                     hmForced = true;
367 |                 }
368 |                 m.setHWDecoderEnabled(hmEnabled, hmForced);
369 |             }
370 |             //添加media  option
371 |             if(mediaOptions != null){
372 |                 ArrayList options = mediaOptions.toArrayList();
373 |                 for(int i=0; i < options.size() - 1 ; i++){
374 |                     String option = (String)options.get(i);
375 |                      m.addOption(option);
376 |                 }
377 |             }
378 |             mMediaPlayer.setMedia(m);
379 |             mMediaPlayer.setScale(0);
380 | 
381 |             if (!vlcOut.areViewsAttached()) {
382 |                 vlcOut.addCallback(callback);
383 |                // vlcOut.setVideoSurface(this.getSurfaceTexture());
384 |                 //vlcOut.setVideoSurface(this.getHolder().getSurface(), this.getHolder());
385 |                 //vlcOut.attachViews(onNewVideoLayoutListener);
386 |                 vlcOut.setVideoSurface(this.getSurfaceTexture());
387 |                 vlcOut.attachViews(onNewVideoLayoutListener);
388 |                // vlcOut.attachSurfaceSlave(surfaceVideo,null,onNewVideoLayoutListener);
389 |                 //vlcOut.setVideoView(this);
390 |                 //vlcOut.attachViews(onNewVideoLayoutListener);
391 |             }
392 |             if(isResume){
393 |                 if(autoplayResume){
394 |                     mMediaPlayer.play();
395 |                 }
396 |             }else{
397 |                 if(autoplay){
398 |                     isPaused = false;
399 |                     mMediaPlayer.play();
400 |                 }
401 |             }
402 |             eventEmitter.loadStart();
403 |         } catch (Exception e) {
404 |            e.printStackTrace();
405 |             //Toast.makeText(getContext(), "Error creating player!", Toast.LENGTH_LONG).show();
406 |         }
407 |     }
408 | 
409 |     private void releasePlayer() {
410 |         if (libvlc == null)
411 |             return;
412 |         mMediaPlayer.stop();
413 |         final IVLCVout vout = mMediaPlayer.getVLCVout();
414 |         vout.removeCallback(callback);
415 |         vout.detachViews();
416 |         //surfaceView.removeOnLayoutChangeListener(onLayoutChangeListener);
417 |         libvlc.release();
418 |         libvlc = null;
419 |     }
420 | 
421 |     /**
422 |      *  视频进度调整
423 |      * @param time
424 |      */
425 |     public void seekTo(long time) {
426 |         if(mMediaPlayer != null){
427 |             mMediaPlayer.setTime(time);
428 | 
429 |             WritableMap map = Arguments.createMap();
430 |             map.putDouble("currentTime",mMediaPlayer.getTime());
431 |             map.putDouble("duration",mMediaPlayer.getLength());
432 |             eventEmitter.onVideoSeek(map);
433 |         }
434 |     }
435 | 
436 |     public void  setPosition(float position){
437 |         if(mMediaPlayer != null) {
438 |             if(position >= 0 && position <= 1){
439 |                 mMediaPlayer.setPosition(position);
440 |             }
441 |         }
442 |     }
443 | 
444 |     /**
445 |      * 设置资源路径
446 |      * @param uri
447 |      * @param isNetStr
448 |      */
449 |     public void setSrc(String uri, boolean isNetStr, boolean autoplay) {
450 |         this.src = uri;
451 |         this.netStrTag = isNetStr;
452 |         createPlayer(autoplay,false);
453 |     }
454 | 
455 |     public void setSrc(ReadableMap src){
456 |         this.srcMap = src;
457 |         createPlayer(true,false);
458 |     }
459 | 
460 | 
461 |     /**
462 |      * 改变播放速率
463 |      * @param rateModifier
464 |      */
465 |     public void setRateModifier(float rateModifier) {
466 |         if(mMediaPlayer != null){
467 |             mMediaPlayer.setRate(rateModifier);
468 |         }
469 |     }
470 | 
471 | 
472 |     /**
473 |      * 改变声音大小
474 |      * @param volumeModifier
475 |      */
476 |     public void setVolumeModifier(int volumeModifier) {
477 |         if(mMediaPlayer != null){
478 |             mMediaPlayer.setVolume(volumeModifier);
479 |         }
480 |     }
481 | 
482 |     /**
483 |      * 改变静音状态
484 |      * @param muted
485 |      */
486 |     public void setMutedModifier(boolean muted) {
487 |         if(mMediaPlayer != null){
488 |             if(muted){
489 |                 this.preVolume = mMediaPlayer.getVolume();
490 |                 mMediaPlayer.setVolume(0);
491 |             }else{
492 |                 mMediaPlayer.setVolume(this.preVolume);
493 |             }
494 |         }
495 |     }
496 | 
497 |     /**
498 |      * 改变播放状态
499 |      * @param paused
500 |      */
501 |     public void setPausedModifier(boolean paused){
502 |         Log.i("paused:",""+paused+":"+mMediaPlayer);
503 |         if(mMediaPlayer != null){
504 |             if(paused){
505 |                 isPaused = true;
506 |                 mMediaPlayer.pause();
507 |             }else{
508 |                 isPaused = false;
509 |                 mMediaPlayer.play();
510 |                 Log.i("do play:",true + "");
511 |             }
512 |         }else{
513 |             createPlayer(!paused,false);
514 |         }
515 |     }
516 | 
517 | 
518 |     /**
519 |      * 截图
520 |      * @param path
521 |      */
522 |     public void doSnapshot(String path){
523 |        return;
524 |     }
525 | 
526 | 
527 |     /**
528 |      * 重新加载视频
529 |      * @param autoplay
530 |      */
531 |     public void doResume(boolean autoplay){
532 |         createPlayer(autoplay,true);
533 |     }
534 | 
535 | 
536 |     public void setRepeatModifier(boolean repeat){
537 |     }
538 | 
539 | 
540 |     /**
541 |      * 改变宽高比
542 |      * @param aspectRatio
543 |      */
544 |     public void setAspectRatio(String aspectRatio){
545 |         if(!autoAspectRatio && mMediaPlayer != null){
546 |             mMediaPlayer.setAspectRatio(aspectRatio);
547 |         }
548 |     }
549 | 
550 |     public void setAutoAspectRatio(boolean auto){
551 |         autoAspectRatio = auto;
552 |     }
553 | 
554 | 
555 |     public void cleanUpResources() {
556 |         if(surfaceView != null){
557 |             surfaceView.removeOnLayoutChangeListener(onLayoutChangeListener);
558 |         }
559 |         stopPlayback();
560 |     }
561 | 
562 |     public void getMetadata() {
563 |         if(mMediaPlayer != null){
564 |           WritableMap map = Arguments.createMap();
565 |           Media media = mMediaPlayer.getMedia();
566 |           String artwork = media.getMeta(Media.Meta.ArtworkURL);
567 | 
568 |           map.putString("type","Metadata");
569 |           map.putString("title",media.getMeta(Media.Meta.Title));
570 |           map.putString("artist",media.getMeta(Media.Meta.Artist));
571 |           map.putString("genre",media.getMeta(Media.Meta.Genre));
572 |           map.putString("copyright",media.getMeta(Media.Meta.Copyright));
573 |           map.putString("album",media.getMeta(Media.Meta.Album));
574 |           map.putString("tracknumber",media.getMeta(Media.Meta.TrackNumber));
575 |           map.putString("description",media.getMeta(Media.Meta.Description));
576 |           map.putString("rating",media.getMeta(Media.Meta.Rating));
577 |           map.putString("date",media.getMeta(Media.Meta.Date));
578 |           map.putString("language",media.getMeta(Media.Meta.Language));
579 |           map.putString("publisher",media.getMeta(Media.Meta.Publisher));
580 |           map.putString("encodedby",media.getMeta(Media.Meta.EncodedBy));
581 |           if (artwork != null) {
582 |             map.putString("artwork",artwork.toString());
583 |           };
584 |           map.putString("trackid",media.getMeta(Media.Meta.TrackID));
585 |           map.putString("tracktotal",media.getMeta(Media.Meta.TrackTotal));
586 |           map.putString("director",media.getMeta(Media.Meta.Director));
587 |           map.putString("season",media.getMeta(Media.Meta.Season));
588 |           map.putString("episode",media.getMeta(Media.Meta.Episode));
589 |           map.putString("showname",media.getMeta(Media.Meta.ShowName));
590 |           map.putString("albumartist",media.getMeta(Media.Meta.AlbumArtist));
591 |           map.putString("discnumber",media.getMeta(Media.Meta.DiscNumber));
592 |           eventEmitter.onVideoStateChange(map);
593 |         }
594 |     }
595 | 
596 |     @Override
597 |     public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
598 |         mVideoWidth = width;
599 |         mVideoHeight = height;
600 |         surfaceVideo = new Surface(surface);
601 |         createPlayer(true,false);
602 |     }
603 | 
604 |     @Override
605 |     public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
606 | 
607 |     }
608 | 
609 |     @Override
610 |     public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
611 |         return true;
612 |     }
613 | 
614 |     @Override
615 |     public void onSurfaceTextureUpdated(SurfaceTexture surface) {
616 |         Log.i("onSurfaceTextureUpdated","onSurfaceTextureUpdated");
617 |     }
618 | 
619 |     // private final Media.EventListener mMediaListener = new Media.EventListener() {
620 |     //     @Override
621 |     //     public void onEvent(Media.Event event) {
622 |     //         switch (event.type) {
623 |     //             case Media.Event.MetaChanged:
624 |     //                 // New metadata received
625 |     //                 Log.i(tag, "Media.Event.MetaChanged:  =" + event.getMetaId());
626 |     //                 break;
627 |     //             case Media.Event.ParsedChanged:
628 |     //                 Log.i(tag, "Media.Event.ParsedChanged  =" + event.getMetaId());
629 |     //                 break;
630 |     //             case Media.Event.StateChanged:
631 |     //                 Log.i(tag, "StateChanged   =" + event.getMetaId());
632 |     //                 break;
633 |     //             default:
634 |     //                 Log.i(tag, "Media.Event.type=" + event.type + "   eventgetParsedStatus=" + event.getParsedStatus());
635 |     //                 break;
636 |     //
637 |     //         }
638 |     //     }
639 |     // };
640 | 
641 |     /*private void changeSurfaceSize(boolean message) {
642 | 
643 |         if (mMediaPlayer != null) {
644 |             final IVLCVout vlcVout = mMediaPlayer.getVLCVout();
645 |             vlcVout.setWindowSize(screenWidth, screenHeight);
646 |         }
647 | 
648 |         double displayWidth = screenWidth, displayHeight = screenHeight;
649 | 
650 |         if (screenWidth < screenHeight) {
651 |             displayWidth = screenHeight;
652 |             displayHeight = screenWidth;
653 |         }
654 | 
655 |         // sanity check
656 |         if (displayWidth * displayHeight <= 1 || mVideoWidth * mVideoHeight <= 1) {
657 |             return;
658 |         }
659 | 
660 |         // compute the aspect ratio
661 |         double aspectRatio, visibleWidth;
662 |         if (mSarDen == mSarNum) {
663 |             *//* No indication about the density, assuming 1:1 *//*
664 |             visibleWidth = mVideoVisibleWidth;
665 |             aspectRatio = (double) mVideoVisibleWidth / (double) mVideoVisibleHeight;
666 |         } else {
667 |             *//* Use the specified aspect ratio *//*
668 |             visibleWidth = mVideoVisibleWidth * (double) mSarNum / mSarDen;
669 |             aspectRatio = visibleWidth / mVideoVisibleHeight;
670 |         }
671 | 
672 |         // compute the display aspect ratio
673 |         double displayAspectRatio = displayWidth / displayHeight;
674 | 
675 |         counter ++;
676 | 
677 |         switch (mCurrentSize) {
678 |             case SURFACE_BEST_FIT:
679 |                 if(counter > 2)
680 |                     Toast.makeText(getContext(), "Best Fit", Toast.LENGTH_SHORT).show();
681 |                 if (displayAspectRatio < aspectRatio)
682 |                     displayHeight = displayWidth / aspectRatio;
683 |                 else
684 |                     displayWidth = displayHeight * aspectRatio;
685 |                 break;
686 |             case SURFACE_FIT_HORIZONTAL:
687 |                 Toast.makeText(getContext(), "Fit Horizontal", Toast.LENGTH_SHORT).show();
688 |                 displayHeight = displayWidth / aspectRatio;
689 |                 break;
690 |             case SURFACE_FIT_VERTICAL:
691 |                 Toast.makeText(getContext(), "Fit Horizontal", Toast.LENGTH_SHORT).show();
692 |                 displayWidth = displayHeight * aspectRatio;
693 |                 break;
694 |             case SURFACE_FILL:
695 |                 Toast.makeText(getContext(), "Fill", Toast.LENGTH_SHORT).show();
696 |                 break;
697 |             case SURFACE_16_9:
698 |                 Toast.makeText(getContext(), "16:9", Toast.LENGTH_SHORT).show();
699 |                 aspectRatio = 16.0 / 9.0;
700 |                 if (displayAspectRatio < aspectRatio)
701 |                     displayHeight = displayWidth / aspectRatio;
702 |                 else
703 |                     displayWidth = displayHeight * aspectRatio;
704 |                 break;
705 |             case SURFACE_4_3:
706 |                 Toast.makeText(getContext(), "4:3", Toast.LENGTH_SHORT).show();
707 |                 aspectRatio = 4.0 / 3.0;
708 |                 if (displayAspectRatio < aspectRatio)
709 |                     displayHeight = displayWidth / aspectRatio;
710 |                 else
711 |                     displayWidth = displayHeight * aspectRatio;
712 |                 break;
713 |             case SURFACE_ORIGINAL:
714 |                 Toast.makeText(getContext(), "Original", Toast.LENGTH_SHORT).show();
715 |                 displayHeight = mVideoVisibleHeight;
716 |                 displayWidth = visibleWidth;
717 |                 break;
718 |         }
719 | 
720 |         // set display size
721 |         int finalWidth = (int) Math.ceil(displayWidth * mVideoWidth / mVideoVisibleWidth);
722 |         int finalHeight = (int) Math.ceil(displayHeight * mVideoHeight / mVideoVisibleHeight);
723 | 
724 |         SurfaceHolder holder = this.getHolder();
725 |         holder.setFixedSize(finalWidth, finalHeight);
726 | 
727 |         ViewGroup.LayoutParams lp = this.getLayoutParams();
728 |         lp.width = finalWidth;
729 |         lp.height = finalHeight;
730 |         this.setLayoutParams(lp);
731 |         this.invalidate();
732 |     }*/
733 | }
734 | 


--------------------------------------------------------------------------------
/android/src/main/java/com/lunarr/vlc/vlcplayer/ReactVlcPlayerViewManager.java:
--------------------------------------------------------------------------------
  1 | package com.lunarr.vlc.vlcplayer;
  2 | 
  3 | import android.content.Context;
  4 | import android.text.TextUtils;
  5 | 
  6 | import com.facebook.react.bridge.ReadableMap;
  7 | import com.facebook.react.common.MapBuilder;
  8 | import com.facebook.react.uimanager.SimpleViewManager;
  9 | import com.facebook.react.uimanager.ThemedReactContext;
 10 | import com.facebook.react.uimanager.annotations.ReactProp;
 11 | 
 12 | import java.util.Map;
 13 | 
 14 | import javax.annotation.Nullable;
 15 | 
 16 | public class ReactVlcPlayerViewManager extends SimpleViewManager<ReactVlcPlayerView> {
 17 | 
 18 |     private static final String REACT_CLASS = "RCTVLCPlayer";
 19 | 
 20 |     private static final String PROP_SRC = "source";
 21 |     private static final String PROP_SRC_URI = "uri";
 22 |     private static final String PROP_SRC_TYPE = "type";
 23 |     private static final String PROP_REPEAT = "repeat";
 24 |     private static final String PROP_PAUSED = "paused";
 25 |     private static final String PROP_MUTED = "muted";
 26 |     private static final String PROP_VOLUME = "volume";
 27 |     private static final String PROP_SEEK = "seek";
 28 |     private static final String PROP_RESUME = "resume";
 29 |     private static final String PROP_RATE = "rate";
 30 |     private static final String PROP_POSITION = "position";
 31 |     private static final String PROP_VIDEO_ASPECT_RATIO = "videoAspectRatio";
 32 |     private static final String PROP_SRC_IS_NETWORK = "isNetwork";
 33 |     private static final String PROP_SNAPSHOT_PATH = "snapshotPath";
 34 |     private static final String PROP_AUTO_ASPECT_RATIO = "autoAspectRatio";
 35 |     private static final String PROP_CLEAR = "clear";
 36 |     private static final String PROP_METADATA = "metadata";
 37 | 
 38 | 
 39 |     @Override
 40 |     public String getName() {
 41 |         return REACT_CLASS;
 42 |     }
 43 | 
 44 |     @Override
 45 |     protected ReactVlcPlayerView createViewInstance(ThemedReactContext themedReactContext) {
 46 |         return new ReactVlcPlayerView(themedReactContext);
 47 |     }
 48 | 
 49 |     @Override
 50 |     public void onDropViewInstance(ReactVlcPlayerView view) {
 51 |         view.cleanUpResources();
 52 |     }
 53 | 
 54 |     @Override
 55 |     public @Nullable Map<String, Object> getExportedCustomDirectEventTypeConstants() {
 56 |         MapBuilder.Builder<String, Object> builder = MapBuilder.builder();
 57 |         for (String event : VideoEventEmitter.Events) {
 58 |             builder.put(event, MapBuilder.of("registrationName", event));
 59 |         }
 60 |         return builder.build();
 61 |     }
 62 | 
 63 |     @ReactProp(name = PROP_CLEAR)
 64 |     public void setClear(final ReactVlcPlayerView videoView, final boolean clear) {
 65 |         videoView.cleanUpResources();
 66 |     }
 67 | 
 68 | 
 69 |     @ReactProp(name = PROP_SRC)
 70 |     public void setSrc(final ReactVlcPlayerView videoView, @Nullable ReadableMap src) {
 71 |         Context context = videoView.getContext().getApplicationContext();
 72 |         String uriString = src.hasKey(PROP_SRC_URI) ? src.getString(PROP_SRC_URI) : null;
 73 |         String extension = src.hasKey(PROP_SRC_TYPE) ? src.getString(PROP_SRC_TYPE) : null;
 74 |         boolean isNetStr = src.getBoolean(PROP_SRC_IS_NETWORK) ? src.getBoolean(PROP_SRC_IS_NETWORK) : false;
 75 |         boolean autoplay = src.getBoolean("autoplay") ? src.getBoolean("autoplay") : true;
 76 |         if (TextUtils.isEmpty(uriString)) {
 77 |             return;
 78 |         }
 79 |         videoView.setSrc(src);
 80 | 
 81 |     }
 82 | 
 83 |     @ReactProp(name = PROP_REPEAT, defaultBoolean = false)
 84 |     public void setRepeat(final ReactVlcPlayerView videoView, final boolean repeat) {
 85 |         videoView.setRepeatModifier(repeat);
 86 |     }
 87 | 
 88 |     @ReactProp(name = PROP_PAUSED, defaultBoolean = false)
 89 |     public void setPaused(final ReactVlcPlayerView videoView, final boolean paused) {
 90 |         videoView.setPausedModifier(paused);
 91 |     }
 92 | 
 93 |     @ReactProp(name = PROP_MUTED, defaultBoolean = false)
 94 |     public void setMuted(final ReactVlcPlayerView videoView, final boolean muted) {
 95 |         videoView.setMutedModifier(muted);
 96 |     }
 97 | 
 98 |     @ReactProp(name = PROP_VOLUME, defaultFloat = 1.0f)
 99 |     public void setVolume(final ReactVlcPlayerView videoView, final float volume) {
100 |         videoView.setVolumeModifier((int)volume);
101 |     }
102 | 
103 | 
104 |     @ReactProp(name = PROP_SEEK)
105 |     public void setSeek(final ReactVlcPlayerView videoView, final float seek) {
106 |         videoView.seekTo(Math.round(seek * 1000f));
107 |         //videoView.seekTo(seek);
108 |     }
109 | 
110 |     @ReactProp(name = PROP_AUTO_ASPECT_RATIO, defaultBoolean = false)
111 |     public void setAutoAspectRatio(final ReactVlcPlayerView videoView, final boolean autoPlay) {
112 |         videoView.setAutoAspectRatio(autoPlay);
113 |     }
114 | 
115 |     @ReactProp(name = PROP_RESUME, defaultBoolean = true)
116 |     public void setResume(final ReactVlcPlayerView videoView, final boolean autoPlay) {
117 |         videoView.doResume(autoPlay);
118 |     }
119 | 
120 | 
121 |     @ReactProp(name = PROP_RATE)
122 |     public void setRate(final ReactVlcPlayerView videoView, final float rate) {
123 |         videoView.setRateModifier(rate);
124 |     }
125 | 
126 |     @ReactProp(name = PROP_POSITION)
127 |     public void setPosition(final ReactVlcPlayerView videoView, final float potision) {
128 |         videoView.setPosition(potision);
129 |     }
130 | 
131 | 
132 | 
133 |     @ReactProp(name = PROP_VIDEO_ASPECT_RATIO)
134 |     public void setVideoAspectRatio(final ReactVlcPlayerView videoView, final String aspectRatio) {
135 |         videoView.setAspectRatio(aspectRatio);
136 |     }
137 | 
138 |     @ReactProp(name = PROP_SNAPSHOT_PATH)
139 |     public void setSnapshotPath(final ReactVlcPlayerView videoView, final String snapshotPath) {
140 |         videoView.doSnapshot(snapshotPath);
141 |     }
142 | 
143 |     @ReactProp(name = PROP_METADATA, defaultBoolean = false)
144 |     public void getMetadata(final ReactVlcPlayerView videoView, final boolean metadata) {
145 |         if (metadata) {
146 |           videoView.getMetadata();
147 |         }
148 |     }
149 | 
150 |     private boolean startsWithValidScheme(String uriString) {
151 |         return uriString.startsWith("http://")
152 |                 || uriString.startsWith("https://")
153 |                 || uriString.startsWith("content://")
154 |                 || uriString.startsWith("file://")
155 |                 || uriString.startsWith("asset://");
156 |     }
157 | }
158 | 


--------------------------------------------------------------------------------
/android/src/main/java/com/lunarr/vlc/vlcplayer/VideoEventEmitter.java:
--------------------------------------------------------------------------------
  1 | package com.lunarr.vlc.vlcplayer;
  2 | 
  3 | import androidx.annotation.StringDef;
  4 | import android.util.Log;
  5 | import android.view.View;
  6 | 
  7 | import com.facebook.react.bridge.Arguments;
  8 | import com.facebook.react.bridge.ReactContext;
  9 | import com.facebook.react.bridge.WritableArray;
 10 | import com.facebook.react.bridge.WritableMap;
 11 | import com.facebook.react.uimanager.events.RCTEventEmitter;
 12 | 
 13 | 
 14 | import java.lang.annotation.Retention;
 15 | import java.lang.annotation.RetentionPolicy;
 16 | 
 17 | class VideoEventEmitter {
 18 | 
 19 |     private final RCTEventEmitter eventEmitter;
 20 | 
 21 |     private int viewId = View.NO_ID;
 22 | 
 23 |     VideoEventEmitter(ReactContext reactContext) {
 24 |         this.eventEmitter = reactContext.getJSModule(RCTEventEmitter.class);
 25 |     }
 26 | 
 27 |     private static final String EVENT_LOAD_START = "onVideoLoadStart";
 28 |     private static final String EVENT_PROGRESS = "onVideoProgress";
 29 |     private static final String EVENT_SEEK = "onVideoSeek";
 30 |     private static final String EVENT_END = "onVideoEnd";
 31 |     private static final String EVENT_SNAPSHOT = "onSnapshot";
 32 |     private static final String EVENT_ON_VIDEO_STATE_CHANGE = "onVideoStateChange";
 33 | 
 34 |     static final String[] Events = {
 35 |             EVENT_LOAD_START,
 36 |             EVENT_PROGRESS,
 37 |             EVENT_SEEK,
 38 |             EVENT_END,
 39 |             EVENT_SNAPSHOT,
 40 |             EVENT_ON_VIDEO_STATE_CHANGE
 41 |     };
 42 | 
 43 |     @Retention(RetentionPolicy.SOURCE)
 44 |     @StringDef({
 45 |             EVENT_LOAD_START,
 46 |             EVENT_PROGRESS,
 47 |             EVENT_SEEK,
 48 |             EVENT_END,
 49 |             EVENT_SNAPSHOT,
 50 |             EVENT_ON_VIDEO_STATE_CHANGE
 51 |     })
 52 | 
 53 |     @interface VideoEvents {
 54 |     }
 55 | 
 56 |     private static final String EVENT_PROP_ERROR = "error";
 57 |     private static final String EVENT_PROP_ERROR_STRING = "errorString";
 58 |     private static final String EVENT_PROP_ERROR_EXCEPTION = "";
 59 | 
 60 | 
 61 |     void setViewId(int viewId) {
 62 |         this.viewId = viewId;
 63 |     }
 64 | 
 65 |     /**
 66 |      * MideaPlayer初始化完毕回调
 67 |      */
 68 |     void loadStart() {
 69 |         WritableMap event = Arguments.createMap();
 70 |         receiveEvent(EVENT_LOAD_START, event);
 71 |     }
 72 | 
 73 | 
 74 |     /**
 75 |      * 视频进度改变回调
 76 |      * @param progress
 77 |      */
 78 |     void progressChanged(WritableMap progress) {
 79 |         receiveEvent(EVENT_PROGRESS, progress);
 80 |     }
 81 | 
 82 |     /**
 83 |      * 视频进度改变回调
 84 |      * @param progress
 85 |      */
 86 |     void onVideoSeek(WritableMap progress) {
 87 |         receiveEvent(EVENT_SEEK, progress);
 88 |     }
 89 | 
 90 | 
 91 |     void error(String errorString, Exception exception) {
 92 |         WritableMap error = Arguments.createMap();
 93 |         error.putString(EVENT_PROP_ERROR_STRING, errorString);
 94 |         error.putString(EVENT_PROP_ERROR_EXCEPTION, exception.getMessage());
 95 |         WritableMap event = Arguments.createMap();
 96 |         event.putMap(EVENT_PROP_ERROR, error);
 97 |         //receiveEvent(EVENT_ERROR, event);
 98 |     }
 99 | 
100 |     /**
101 |      * 截图回调
102 |      * @param result
103 |      */
104 |     void onSnapshot(int result){
105 |         WritableMap map = Arguments.createMap();
106 |         map.putInt("isSuccess",result);
107 |         receiveEvent(EVENT_SNAPSHOT, map);
108 |     }
109 | 
110 |     /**
111 |      * 视频状态改变回调
112 |      * @param map
113 |      */
114 |     void onVideoStateChange(WritableMap map){
115 |         receiveEvent(EVENT_ON_VIDEO_STATE_CHANGE, map);
116 |     }
117 | 
118 |     private void receiveEvent(@VideoEvents String type, WritableMap event) {
119 |         eventEmitter.receiveEvent(viewId, type, event);
120 |     }
121 | 
122 | }
123 | 


--------------------------------------------------------------------------------
/android/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 |     <string name="app_name">vlcplayer</string>
3 | </resources>
4 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
  1 | import React from "react";
  2 | import { StyleSheet, View, Platform } from "react-native";
  3 | import { Image } from "react-native";
  4 | import PropTypes from "prop-types";
  5 | import Player from "./VLCPlayer";
  6 | 
  7 | export default class VLCPlayer extends React.PureComponent {
  8 |   constructor(props) {
  9 |     super(props);
 10 |     this.seek = this.seek.bind(this);
 11 |     this.resume = this.resume.bind(this);
 12 |     this.play = this.play.bind(this);
 13 |     this.getMetadata = this.getMetadata.bind(this);
 14 |     this.snapshot = this.snapshot.bind(this);
 15 |     this._onProgress = this._onProgress.bind(this);
 16 |     this._onSeek = this._onSeek.bind(this);
 17 |     this._onLoadStart = this._onLoadStart.bind(this);
 18 |     this._onSnapshot = this._onSnapshot.bind(this);
 19 |     this._onVideoStateChange = this._onVideoStateChange.bind(this);
 20 |     this.clear = this.clear.bind(this);
 21 |     this.changeVideoAspectRatio = this.changeVideoAspectRatio.bind(this);
 22 |   }
 23 | 
 24 |   static defaultProps = {
 25 |     autoplay: true,
 26 |     initType: 2,
 27 |     initOptions: ["--play-and-pause", "--no-color", "--verbose=0"],
 28 |     style: {},
 29 |   };
 30 | 
 31 |   setNativeProps(nativeProps) {
 32 |     this._video.setNativeProps(nativeProps);
 33 |   }
 34 | 
 35 |   getMetadata() {
 36 |     this.setNativeProps({ metadata: true });
 37 |   }
 38 | 
 39 |   clear() {
 40 |     this.setNativeProps({ clear: true });
 41 |   }
 42 | 
 43 |   seek(timeSec) {
 44 |     if (Platform.OS === "ios") {
 45 |       this.setNativeProps({ seekTime: timeSec });
 46 |     } else {
 47 |       this.setNativeProps({ seek: timeSec });
 48 |     }
 49 |   }
 50 | 
 51 |   autoAspectRatio(isAuto) {
 52 |     this.setNativeProps({ autoAspectRatio: isAuto });
 53 |   }
 54 | 
 55 |   changeVideoAspectRatio(ratio) {
 56 |     this.setNativeProps({ videoAspectRatio: ratio });
 57 |   }
 58 | 
 59 |   play(paused) {
 60 |     this.setNativeProps({ paused: paused });
 61 |   }
 62 | 
 63 |   position(position) {
 64 |     this.setNativeProps({ position: position });
 65 |   }
 66 | 
 67 |   resume(isResume) {
 68 |     this.setNativeProps({ resume: isResume });
 69 |   }
 70 | 
 71 |   snapshot(path) {
 72 |     this.setNativeProps({ snapshotPath: path });
 73 |   }
 74 | 
 75 |   _onVideoStateChange({ nativeEvent }) {
 76 |     switch (nativeEvent.type) {
 77 |       case "Opening":
 78 |         this.props.onLoad &&
 79 |           this.props.onLoad({
 80 |             currentTime: nativeEvent.currentTime / 1000,
 81 |             duration: nativeEvent.duration / 1000,
 82 |           });
 83 |         break;
 84 |       case "Buffering":
 85 |         this.props.onBuffer && this.props.onBuffer(nativeEvent);
 86 |         break;
 87 |       case "Metadata":
 88 |         this.props.onMetadata && this.props.onMetadata(nativeEvent);
 89 |         break;
 90 |       case "Stopped":
 91 |         this.props.onStopped && this.props.onStopped(nativeEvent);
 92 |         break;
 93 |       case "Ended":
 94 |         this.props.onEnd && this.props.onEnd(nativeEvent);
 95 |         break;
 96 |       case "Error":
 97 |         this.props.onError && this.props.onError(nativeEvent);
 98 |         break;
 99 |       default:
100 |         this.props.onVideoStateChange &&
101 |           this.props.onVideoStateChange(nativeEvent);
102 |     }
103 |   }
104 | 
105 |   _onLoadStart(event) {
106 |     if (this.props.onLoadStart) {
107 |       this.props.onLoadStart(event.nativeEvent);
108 |     }
109 |   }
110 | 
111 |   _onProgress({ nativeEvent }) {
112 |     if (this.props.onProgress) {
113 |       this.props.onProgress({
114 |         currentTime: nativeEvent.currentTime / 1000,
115 |         duration: nativeEvent.duration / 1000,
116 |       });
117 |     }
118 |   }
119 | 
120 |   _onSeek({ nativeEvent }) {
121 |     if (this.props.onSeek) {
122 |       this.props.onSeek({
123 |         currentTime: nativeEvent.currentTime / 1000,
124 |         duration: nativeEvent.duration / 1000,
125 |       });
126 |     }
127 |   }
128 | 
129 |   _onSnapshot(event) {
130 |     if (this.props.onSnapshot) {
131 |       this.props.onSnapshot(event.nativeEvent);
132 |     }
133 |   }
134 | 
135 |   render() {
136 |     const source = Image.resolveAssetSource({ ...this.props.source }) || {};
137 |     let uri = source.uri || "";
138 |     let isNetwork = !!(uri && uri.match(/^https?:/));
139 |     const isAsset = !!(
140 |       uri && uri.match(/^(assets-library|file|content|ms-appx|ms-appdata):/)
141 |     );
142 |     if (!isAsset) {
143 |       isNetwork = true;
144 |     }
145 |     if (uri && uri.match(/^\//)) {
146 |       isNetwork = false;
147 |     }
148 |     if (Platform.OS === "ios") {
149 |       source.mediaOptions = this.props.mediaOptions || {};
150 |     } else {
151 |       let mediaOptionsList = [];
152 |       let mediaOptions = this.props.mediaOptions || {};
153 |       let keys = Object.keys(mediaOptions);
154 |       for (let i = 0; i < keys.length - 1; i++) {
155 |         let optionKey = keys[i];
156 |         let optionValue = mediaOptions[optionKey];
157 |         mediaOptionsList.push(optionKey + "=" + optionValue);
158 |       }
159 |       source.mediaOptions = mediaOptionsList;
160 |     }
161 |     source.initOptions = this.props.initOptions;
162 |     source.isNetwork = isNetwork;
163 |     source.autoplay = this.props.autoplay;
164 |     if (
165 |       !isNaN(this.props.hwDecoderEnabled) &&
166 |       !isNaN(this.props.hwDecoderForced)
167 |     ) {
168 |       source.hwDecoderEnabled = this.props.hwDecoderEnabled;
169 |       source.hwDecoderForced = this.props.hwDecoderForced;
170 |     }
171 |     source.initType = this.props.initType;
172 | 
173 |     //repeat the input media
174 |     //source.initOptions.push('--input-repeat=1000');
175 |     const nativeProps = {
176 |       ...this.props,
177 |       source,
178 |       style: [styles.base, this.props.style],
179 |       onVideoLoadStart: this._onLoadStart,
180 |       onVideoProgress: this._onProgress,
181 |       onVideoSeek: this._onSeek,
182 |       onVideoStateChange: this._onVideoStateChange,
183 |       onSnapshot: this._onSnapshot,
184 |     };
185 | 
186 |     return (
187 |       <Player
188 |         ref={(ref) => {
189 |           this._video = ref;
190 |         }}
191 |         {...nativeProps}
192 |       />
193 |     );
194 |   }
195 | }
196 | 
197 | VLCPlayer.propTypes = {
198 |   /* Native only */
199 |   rate: PropTypes.number,
200 |   seek: PropTypes.number,
201 |   resume: PropTypes.bool,
202 |   position: PropTypes.number,
203 |   snapshotPath: PropTypes.string,
204 |   paused: PropTypes.bool,
205 |   autoAspectRatio: PropTypes.bool,
206 |   videoAspectRatio: PropTypes.string,
207 | 
208 |   /* Volume: 0-200 */
209 |   volume: PropTypes.number,
210 |   volumeUp: PropTypes.number,
211 |   volumeDown: PropTypes.number,
212 |   repeat: PropTypes.bool,
213 |   muted: PropTypes.bool,
214 | 
215 |   hwDecoderEnabled: PropTypes.number,
216 |   hwDecoderForced: PropTypes.number,
217 | 
218 |   onVideoLoadStart: PropTypes.func,
219 |   onVideoStateChange: PropTypes.func,
220 |   onVideoProgress: PropTypes.func,
221 |   onSnapshot: PropTypes.func,
222 |   onOpen: PropTypes.func,
223 |   onLoadStart: PropTypes.func,
224 | 
225 |   /* Wrapper component */
226 |   source: PropTypes.oneOfType([
227 |     PropTypes.object.isRequired,
228 |     PropTypes.number.isRequired,
229 |   ]),
230 |   play: PropTypes.func,
231 |   snapshot: PropTypes.func,
232 |   onError: PropTypes.func,
233 |   onSeek: PropTypes.func,
234 |   onProgress: PropTypes.func,
235 |   onMetadata: PropTypes.func,
236 |   onBuffer: PropTypes.func,
237 |   onEnd: PropTypes.func,
238 |   onStopped: PropTypes.func,
239 | 
240 |   /* Required by react-native */
241 |   scaleX: PropTypes.number,
242 |   scaleY: PropTypes.number,
243 |   translateX: PropTypes.number,
244 |   translateY: PropTypes.number,
245 |   rotation: PropTypes.number,
246 |   ...View.propTypes,
247 | };
248 | 
249 | const styles = StyleSheet.create({
250 |   base: {
251 |     overflow: "hidden",
252 |   },
253 | });
254 | 


--------------------------------------------------------------------------------
/ios/RCTVLCPlayer.xcodeproj/project.pbxproj:
--------------------------------------------------------------------------------
  1 | // !$*UTF8*$!
  2 | {
  3 | 	archiveVersion = 1;
  4 | 	classes = {
  5 | 	};
  6 | 	objectVersion = 46;
  7 | 	objects = {
  8 | 
  9 | /* Begin PBXBuildFile section */
 10 | 		0C1A0ECA1D07E18700441684 /* RCTVLCPlayerManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 0C1A0EC81D07E18700441684 /* RCTVLCPlayerManager.m */; };
 11 | 		0CA30C481D07E0DB003B09F9 /* RCTVLCPlayer.h in CopyFiles */ = {isa = PBXBuildFile; fileRef = 0CA30C471D07E0DB003B09F9 /* RCTVLCPlayer.h */; };
 12 | 		0CA30C4A1D07E0DB003B09F9 /* RCTVLCPlayer.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CA30C491D07E0DB003B09F9 /* RCTVLCPlayer.m */; };
 13 | /* End PBXBuildFile section */
 14 | 
 15 | /* Begin PBXCopyFilesBuildPhase section */
 16 | 		0CA30C421D07E0DB003B09F9 /* CopyFiles */ = {
 17 | 			isa = PBXCopyFilesBuildPhase;
 18 | 			buildActionMask = 2147483647;
 19 | 			dstPath = "include/$(PRODUCT_NAME)";
 20 | 			dstSubfolderSpec = 16;
 21 | 			files = (
 22 | 				0CA30C481D07E0DB003B09F9 /* RCTVLCPlayer.h in CopyFiles */,
 23 | 			);
 24 | 			runOnlyForDeploymentPostprocessing = 0;
 25 | 		};
 26 | /* End PBXCopyFilesBuildPhase section */
 27 | 
 28 | /* Begin PBXFileReference section */
 29 | 		0C1A0EC81D07E18700441684 /* RCTVLCPlayerManager.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTVLCPlayerManager.m; sourceTree = "<group>"; };
 30 | 		0C1A0EC91D07E18700441684 /* RCTVLCPlayerManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RCTVLCPlayerManager.h; sourceTree = "<group>"; };
 31 | 		0CA30C441D07E0DB003B09F9 /* libRCTVLCPlayer.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libRCTVLCPlayer.a; sourceTree = BUILT_PRODUCTS_DIR; };
 32 | 		0CA30C471D07E0DB003B09F9 /* RCTVLCPlayer.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RCTVLCPlayer.h; sourceTree = "<group>"; };
 33 | 		0CA30C491D07E0DB003B09F9 /* RCTVLCPlayer.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RCTVLCPlayer.m; sourceTree = "<group>"; };
 34 | /* End PBXFileReference section */
 35 | 
 36 | /* Begin PBXFrameworksBuildPhase section */
 37 | 		0CA30C411D07E0DB003B09F9 /* Frameworks */ = {
 38 | 			isa = PBXFrameworksBuildPhase;
 39 | 			buildActionMask = 2147483647;
 40 | 			files = (
 41 | 			);
 42 | 			runOnlyForDeploymentPostprocessing = 0;
 43 | 		};
 44 | /* End PBXFrameworksBuildPhase section */
 45 | 
 46 | /* Begin PBXGroup section */
 47 | 		0CA30C3B1D07E0DB003B09F9 = {
 48 | 			isa = PBXGroup;
 49 | 			children = (
 50 | 				0CA30C461D07E0DB003B09F9 /* RCTVLCPlayer */,
 51 | 				0CA30C451D07E0DB003B09F9 /* Products */,
 52 | 			);
 53 | 			sourceTree = "<group>";
 54 | 		};
 55 | 		0CA30C451D07E0DB003B09F9 /* Products */ = {
 56 | 			isa = PBXGroup;
 57 | 			children = (
 58 | 				0CA30C441D07E0DB003B09F9 /* libRCTVLCPlayer.a */,
 59 | 			);
 60 | 			name = Products;
 61 | 			sourceTree = "<group>";
 62 | 		};
 63 | 		0CA30C461D07E0DB003B09F9 /* RCTVLCPlayer */ = {
 64 | 			isa = PBXGroup;
 65 | 			children = (
 66 | 				0C1A0EC81D07E18700441684 /* RCTVLCPlayerManager.m */,
 67 | 				0C1A0EC91D07E18700441684 /* RCTVLCPlayerManager.h */,
 68 | 				0CA30C471D07E0DB003B09F9 /* RCTVLCPlayer.h */,
 69 | 				0CA30C491D07E0DB003B09F9 /* RCTVLCPlayer.m */,
 70 | 			);
 71 | 			path = RCTVLCPlayer;
 72 | 			sourceTree = "<group>";
 73 | 		};
 74 | /* End PBXGroup section */
 75 | 
 76 | /* Begin PBXNativeTarget section */
 77 | 		0CA30C431D07E0DB003B09F9 /* RCTVLCPlayer */ = {
 78 | 			isa = PBXNativeTarget;
 79 | 			buildConfigurationList = 0CA30C4D1D07E0DB003B09F9 /* Build configuration list for PBXNativeTarget "RCTVLCPlayer" */;
 80 | 			buildPhases = (
 81 | 				0CA30C401D07E0DB003B09F9 /* Sources */,
 82 | 				0CA30C411D07E0DB003B09F9 /* Frameworks */,
 83 | 				0CA30C421D07E0DB003B09F9 /* CopyFiles */,
 84 | 			);
 85 | 			buildRules = (
 86 | 			);
 87 | 			dependencies = (
 88 | 			);
 89 | 			name = RCTVLCPlayer;
 90 | 			productName = RCTVLCPlayer;
 91 | 			productReference = 0CA30C441D07E0DB003B09F9 /* libRCTVLCPlayer.a */;
 92 | 			productType = "com.apple.product-type.library.static";
 93 | 		};
 94 | /* End PBXNativeTarget section */
 95 | 
 96 | /* Begin PBXProject section */
 97 | 		0CA30C3C1D07E0DB003B09F9 /* Project object */ = {
 98 | 			isa = PBXProject;
 99 | 			attributes = {
100 | 				LastUpgradeCheck = 0730;
101 | 				ORGANIZATIONNAME = "熊川";
102 | 				TargetAttributes = {
103 | 					0CA30C431D07E0DB003B09F9 = {
104 | 						CreatedOnToolsVersion = 7.3.1;
105 | 					};
106 | 				};
107 | 			};
108 | 			buildConfigurationList = 0CA30C3F1D07E0DB003B09F9 /* Build configuration list for PBXProject "RCTVLCPlayer" */;
109 | 			compatibilityVersion = "Xcode 3.2";
110 | 			developmentRegion = English;
111 | 			hasScannedForEncodings = 0;
112 | 			knownRegions = (
113 | 				English,
114 | 				en,
115 | 			);
116 | 			mainGroup = 0CA30C3B1D07E0DB003B09F9;
117 | 			productRefGroup = 0CA30C451D07E0DB003B09F9 /* Products */;
118 | 			projectDirPath = "";
119 | 			projectRoot = "";
120 | 			targets = (
121 | 				0CA30C431D07E0DB003B09F9 /* RCTVLCPlayer */,
122 | 			);
123 | 		};
124 | /* End PBXProject section */
125 | 
126 | /* Begin PBXSourcesBuildPhase section */
127 | 		0CA30C401D07E0DB003B09F9 /* Sources */ = {
128 | 			isa = PBXSourcesBuildPhase;
129 | 			buildActionMask = 2147483647;
130 | 			files = (
131 | 				0C1A0ECA1D07E18700441684 /* RCTVLCPlayerManager.m in Sources */,
132 | 				0CA30C4A1D07E0DB003B09F9 /* RCTVLCPlayer.m in Sources */,
133 | 			);
134 | 			runOnlyForDeploymentPostprocessing = 0;
135 | 		};
136 | /* End PBXSourcesBuildPhase section */
137 | 
138 | /* Begin XCBuildConfiguration section */
139 | 		0CA30C4B1D07E0DB003B09F9 /* Debug */ = {
140 | 			isa = XCBuildConfiguration;
141 | 			buildSettings = {
142 | 				ALWAYS_SEARCH_USER_PATHS = NO;
143 | 				CLANG_ANALYZER_NONNULL = YES;
144 | 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
145 | 				CLANG_CXX_LIBRARY = "libc++";
146 | 				CLANG_ENABLE_MODULES = YES;
147 | 				CLANG_ENABLE_OBJC_ARC = YES;
148 | 				CLANG_WARN_BOOL_CONVERSION = YES;
149 | 				CLANG_WARN_CONSTANT_CONVERSION = YES;
150 | 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
151 | 				CLANG_WARN_EMPTY_BODY = YES;
152 | 				CLANG_WARN_ENUM_CONVERSION = YES;
153 | 				CLANG_WARN_INT_CONVERSION = YES;
154 | 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
155 | 				CLANG_WARN_UNREACHABLE_CODE = YES;
156 | 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
157 | 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
158 | 				COPY_PHASE_STRIP = NO;
159 | 				DEBUG_INFORMATION_FORMAT = dwarf;
160 | 				ENABLE_STRICT_OBJC_MSGSEND = YES;
161 | 				ENABLE_TESTABILITY = YES;
162 | 				GCC_C_LANGUAGE_STANDARD = gnu99;
163 | 				GCC_DYNAMIC_NO_PIC = NO;
164 | 				GCC_NO_COMMON_BLOCKS = YES;
165 | 				GCC_OPTIMIZATION_LEVEL = 0;
166 | 				GCC_PREPROCESSOR_DEFINITIONS = (
167 | 					"DEBUG=1",
168 | 					"$(inherited)",
169 | 				);
170 | 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
171 | 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
172 | 				GCC_WARN_UNDECLARED_SELECTOR = YES;
173 | 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
174 | 				GCC_WARN_UNUSED_FUNCTION = YES;
175 | 				GCC_WARN_UNUSED_VARIABLE = YES;
176 | 				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
177 | 				MTL_ENABLE_DEBUG_INFO = YES;
178 | 				ONLY_ACTIVE_ARCH = YES;
179 | 				SDKROOT = iphoneos;
180 | 				VALID_ARCHS = "arm64 armv7 armv7s";
181 | 			};
182 | 			name = Debug;
183 | 		};
184 | 		0CA30C4C1D07E0DB003B09F9 /* Release */ = {
185 | 			isa = XCBuildConfiguration;
186 | 			buildSettings = {
187 | 				ALWAYS_SEARCH_USER_PATHS = NO;
188 | 				CLANG_ANALYZER_NONNULL = YES;
189 | 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
190 | 				CLANG_CXX_LIBRARY = "libc++";
191 | 				CLANG_ENABLE_MODULES = YES;
192 | 				CLANG_ENABLE_OBJC_ARC = YES;
193 | 				CLANG_WARN_BOOL_CONVERSION = YES;
194 | 				CLANG_WARN_CONSTANT_CONVERSION = YES;
195 | 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
196 | 				CLANG_WARN_EMPTY_BODY = YES;
197 | 				CLANG_WARN_ENUM_CONVERSION = YES;
198 | 				CLANG_WARN_INT_CONVERSION = YES;
199 | 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
200 | 				CLANG_WARN_UNREACHABLE_CODE = YES;
201 | 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
202 | 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
203 | 				COPY_PHASE_STRIP = NO;
204 | 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
205 | 				ENABLE_NS_ASSERTIONS = NO;
206 | 				ENABLE_STRICT_OBJC_MSGSEND = YES;
207 | 				GCC_C_LANGUAGE_STANDARD = gnu99;
208 | 				GCC_NO_COMMON_BLOCKS = YES;
209 | 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
210 | 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
211 | 				GCC_WARN_UNDECLARED_SELECTOR = YES;
212 | 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
213 | 				GCC_WARN_UNUSED_FUNCTION = YES;
214 | 				GCC_WARN_UNUSED_VARIABLE = YES;
215 | 				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
216 | 				MTL_ENABLE_DEBUG_INFO = NO;
217 | 				SDKROOT = iphoneos;
218 | 				VALIDATE_PRODUCT = YES;
219 | 				VALID_ARCHS = "arm64 armv7 armv7s";
220 | 			};
221 | 			name = Release;
222 | 		};
223 | 		0CA30C4E1D07E0DB003B09F9 /* Debug */ = {
224 | 			isa = XCBuildConfiguration;
225 | 			buildSettings = {
226 | 				FRAMEWORK_SEARCH_PATHS = (
227 | 					"$(SRCROOT)/../../../vlcKit",
228 | 					"\"$(SRCROOT)/../../../ios/Pods/MobileVLCKit-unstable/MobileVLCKit-binary\"",
229 | 				);
230 | 				HEADER_SEARCH_PATHS = (
231 | 					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
232 | 					"$(inherited)",
233 | 					"$(SRCROOT)/../../react-native/React/**",
234 | 					"$(SRCROOT)/node_modules/react-native/React/**",
235 | 					"$(SRCROOT)/../../../ios/Pods/MobileVLCKit-unstable/MobileVLCKit-binary/MobileVLCKit.framework",
236 | 				);
237 | 				ONLY_ACTIVE_ARCH = YES;
238 | 				OTHER_LDFLAGS = "-ObjC";
239 | 				PRODUCT_NAME = "$(TARGET_NAME)";
240 | 				SKIP_INSTALL = YES;
241 | 				VALID_ARCHS = "arm64 armv7 armv7s";
242 | 			};
243 | 			name = Debug;
244 | 		};
245 | 		0CA30C4F1D07E0DB003B09F9 /* Release */ = {
246 | 			isa = XCBuildConfiguration;
247 | 			buildSettings = {
248 | 				FRAMEWORK_SEARCH_PATHS = (
249 | 					"$(SRCROOT)/../../../vlcKit",
250 | 					"\"$(SRCROOT)/../../../ios/Pods/MobileVLCKit-unstable/MobileVLCKit-binary\"",
251 | 				);
252 | 				HEADER_SEARCH_PATHS = (
253 | 					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
254 | 					"$(inherited)",
255 | 					"$(SRCROOT)/../../react-native/React/**",
256 | 					"$(SRCROOT)/node_modules/react-native/React/**",
257 | 					"$(SRCROOT)/../../../ios/Pods/MobileVLCKit-unstable/MobileVLCKit-binary/MobileVLCKit.framework",
258 | 				);
259 | 				ONLY_ACTIVE_ARCH = NO;
260 | 				OTHER_LDFLAGS = "-ObjC";
261 | 				PRODUCT_NAME = "$(TARGET_NAME)";
262 | 				SKIP_INSTALL = YES;
263 | 				VALID_ARCHS = "arm64 armv7 armv7s";
264 | 			};
265 | 			name = Release;
266 | 		};
267 | /* End XCBuildConfiguration section */
268 | 
269 | /* Begin XCConfigurationList section */
270 | 		0CA30C3F1D07E0DB003B09F9 /* Build configuration list for PBXProject "RCTVLCPlayer" */ = {
271 | 			isa = XCConfigurationList;
272 | 			buildConfigurations = (
273 | 				0CA30C4B1D07E0DB003B09F9 /* Debug */,
274 | 				0CA30C4C1D07E0DB003B09F9 /* Release */,
275 | 			);
276 | 			defaultConfigurationIsVisible = 0;
277 | 			defaultConfigurationName = Release;
278 | 		};
279 | 		0CA30C4D1D07E0DB003B09F9 /* Build configuration list for PBXNativeTarget "RCTVLCPlayer" */ = {
280 | 			isa = XCConfigurationList;
281 | 			buildConfigurations = (
282 | 				0CA30C4E1D07E0DB003B09F9 /* Debug */,
283 | 				0CA30C4F1D07E0DB003B09F9 /* Release */,
284 | 			);
285 | 			defaultConfigurationIsVisible = 0;
286 | 			defaultConfigurationName = Release;
287 | 		};
288 | /* End XCConfigurationList section */
289 | 	};
290 | 	rootObject = 0CA30C3C1D07E0DB003B09F9 /* Project object */;
291 | }
292 | 


--------------------------------------------------------------------------------
/ios/RCTVLCPlayer/RCTVLCPlayer.h:
--------------------------------------------------------------------------------
 1 | #import "React/RCTView.h"
 2 | 
 3 | @class RCTEventDispatcher;
 4 | 
 5 | @interface RCTVLCPlayer : UIView
 6 | 
 7 | @property (nonatomic, copy) RCTDirectEventBlock onVideoProgress;
 8 | @property (nonatomic, copy) RCTDirectEventBlock onVideoPaused;
 9 | @property (nonatomic, copy) RCTDirectEventBlock onVideoStopped;
10 | @property (nonatomic, copy) RCTDirectEventBlock onVideoBuffering;
11 | @property (nonatomic, copy) RCTDirectEventBlock onVideoSeek;
12 | @property (nonatomic, copy) RCTDirectEventBlock onVideoEnded;
13 | @property (nonatomic, copy) RCTDirectEventBlock onVideoError;
14 | @property (nonatomic, copy) RCTDirectEventBlock onVideoOpen;
15 | @property (nonatomic, copy) RCTDirectEventBlock onVideoLoadStart;
16 | @property (nonatomic, copy) RCTDirectEventBlock onSnapshot;
17 | @property (nonatomic, copy) RCTDirectEventBlock onVideoStateChange;
18 | 
19 | - (instancetype)initWithEventDispatcher:(RCTEventDispatcher *)eventDispatcher NS_DESIGNATED_INITIALIZER;
20 | 
21 | @end
22 | 


--------------------------------------------------------------------------------
/ios/RCTVLCPlayer/RCTVLCPlayer.m:
--------------------------------------------------------------------------------
  1 | #import "React/RCTConvert.h"
  2 | #import "RCTVLCPlayer.h"
  3 | #import "React/RCTBridgeModule.h"
  4 | #import "React/RCTEventDispatcher.h"
  5 | #import "React/UIView+React.h"
  6 | #import <MobileVLCKit/MobileVLCKit.h>
  7 | #import <AVFoundation/AVFoundation.h>
  8 | static NSString *const statusKeyPath = @"status";
  9 | static NSString *const playbackLikelyToKeepUpKeyPath = @"playbackLikelyToKeepUp";
 10 | static NSString *const playbackBufferEmptyKeyPath = @"playbackBufferEmpty";
 11 | static NSString *const readyForDisplayKeyPath = @"readyForDisplay";
 12 | static NSString *const playbackRate = @"rate";
 13 | 
 14 | @interface RCTVLCPlayer () <VLCMediaPlayerDelegate,VLCMediaDelegate>
 15 | @end
 16 | 
 17 | @implementation RCTVLCPlayer
 18 | {
 19 | 
 20 |     /* Required to publish events */
 21 |     RCTEventDispatcher *_eventDispatcher;
 22 |     VLCMediaPlayer *_player;
 23 | 
 24 |     NSDictionary * _source;
 25 |     BOOL _paused;
 26 |     BOOL _started;
 27 | 
 28 | }
 29 | 
 30 | - (instancetype)initWithEventDispatcher:(RCTEventDispatcher *)eventDispatcher
 31 | {
 32 |     if ((self = [super init])) {
 33 |         _eventDispatcher = eventDispatcher;
 34 | 
 35 |         [[NSNotificationCenter defaultCenter] addObserver:self
 36 |                                                  selector:@selector(applicationWillResignActive:)
 37 |                                                      name:UIApplicationWillResignActiveNotification
 38 |                                                    object:nil];
 39 | 
 40 |         [[NSNotificationCenter defaultCenter] addObserver:self
 41 |                                                  selector:@selector(applicationWillEnterForeground:)
 42 |                                                      name:UIApplicationWillEnterForegroundNotification
 43 |                                                    object:nil];
 44 | 
 45 |     }
 46 | 
 47 |     return self;
 48 | }
 49 | 
 50 | 
 51 | - (void)applicationWillResignActive:(NSNotification *)notification
 52 | {
 53 |     if (!_paused) {
 54 |         [self setPaused:_paused];
 55 |     }
 56 | }
 57 | 
 58 | - (void)applicationWillEnterForeground:(NSNotification *)notification
 59 | {
 60 |     [self applyModifiers];
 61 | }
 62 | 
 63 | - (void)applyModifiers
 64 | {
 65 |     if(!_paused)
 66 |         [self play];
 67 | }
 68 | 
 69 | - (void)setPaused:(BOOL)paused
 70 | {
 71 |     if(_player){
 72 |         if(!paused){
 73 |             [self play];
 74 |         }else {
 75 |             [_player pause];
 76 |             _paused =  YES;
 77 |             _started = NO;
 78 |         }
 79 |     }
 80 | }
 81 | 
 82 | -(void)play
 83 | {
 84 |     if(_player){
 85 |         [_player play];
 86 |         _paused = NO;
 87 |         _started = YES;
 88 |     }
 89 | }
 90 | 
 91 | -(void)setResume:(BOOL)autoplay
 92 | {
 93 |     @try{
 94 |         char * videoRatio = nil;
 95 |         if(_player){
 96 |             videoRatio = _player.videoAspectRatio;
 97 |             [_player stop];
 98 |             _player = nil;
 99 |         }
100 |         NSMutableDictionary* mediaOptions = [_source objectForKey:@"mediaOptions"];
101 |         NSArray* options = [_source objectForKey:@"initOptions"];
102 |         NSString* uri    = [_source objectForKey:@"uri"];
103 |         NSInteger initType = [RCTConvert NSInteger:[_source objectForKey:@"initType"]];
104 |         BOOL autoplay = [RCTConvert BOOL:[_source objectForKey:@"autoplay"]];
105 |         BOOL isNetWork   = [RCTConvert BOOL:[_source objectForKey:@"isNetwork"]];
106 |         NSURL* _uri    = [NSURL URLWithString:uri];
107 |         if(uri && uri.length > 0){
108 |             // init player && play
109 |             if(initType == 2){
110 |                 _player = [[VLCMediaPlayer alloc] initWithOptions:options];
111 |             }else{
112 |                 _player = [[VLCMediaPlayer alloc] init];
113 |             }
114 |             [_player setDrawable:self];
115 |             _player.delegate = self;
116 |             _player.scaleFactor = 0;
117 |             //设置缓存多少毫秒
118 |             // [mediaDictonary setObject:@"1500" forKey:@"network-caching"];
119 |             VLCMedia *media = nil;
120 |             if(isNetWork){
121 |                 media = [VLCMedia mediaWithURL:_uri];
122 |             }else{
123 |                 media = [VLCMedia mediaWithPath: uri];
124 |             }
125 |             media.delegate = self;
126 |             if(mediaOptions){
127 |                 [media addOptions:mediaOptions];
128 |             }
129 |             /*if(videoRatio){
130 |                 _player.videoAspectRatio = videoRatio;
131 |             }*/
132 |             [media parseWithOptions:VLCMediaParseLocal|VLCMediaFetchLocal|VLCMediaParseNetwork|VLCMediaFetchNetwork];
133 |             _player.media = media;
134 |             if(autoplay)
135 |                 [self play];
136 |             if(self.onVideoLoadStart){
137 |                 self.onVideoLoadStart(@{
138 |                                         @"target": self.reactTag
139 |                                         });
140 |             }
141 |         }
142 |     }
143 |     @catch(NSException *exception){
144 |         NSLog(@"%@", exception);
145 |     }
146 | }
147 | 
148 | -(void)setSource:(NSDictionary *)source
149 | {
150 |     @try{
151 |         if(_player){
152 |             [_player stop];
153 |             _player = nil;
154 |         }
155 |         _source = source;
156 |         NSMutableDictionary* mediaOptions = [source objectForKey:@"mediaOptions"];
157 |         NSArray* options = [source objectForKey:@"initOptions"];
158 |         NSString* uri    = [source objectForKey:@"uri"];
159 |         NSInteger initType = [RCTConvert NSInteger:[source objectForKey:@"initType"]];
160 |         BOOL autoplay = [RCTConvert BOOL:[source objectForKey:@"autoplay"]];
161 |         BOOL isNetWork   = [RCTConvert BOOL:[source objectForKey:@"isNetwork"]];
162 |         NSURL* _uri    = [NSURL URLWithString:uri];
163 |         if(uri && uri.length > 0){
164 |             // init player && play
165 |             if(initType == 2){
166 |                 _player = [[VLCMediaPlayer alloc] initWithOptions:options];
167 |             }else{
168 |                 _player = [[VLCMediaPlayer alloc] init];
169 |             }
170 |             [_player setDrawable:self];
171 |             _player.delegate = self;
172 |             _player.scaleFactor = 0;
173 |             //设置缓存多少毫秒
174 |             // [mediaDictonary setObject:@"1500" forKey:@"network-caching"];
175 |             VLCMedia *media = nil;
176 |             if(isNetWork){
177 |                 media = [VLCMedia mediaWithURL:_uri];
178 |             }else{
179 |                 media = [VLCMedia mediaWithPath: uri];
180 |             }
181 |             if(media){
182 |                 media.delegate = self;
183 |                 if(mediaOptions){
184 |                     [media addOptions:mediaOptions];
185 |                 }
186 |                 [media parseWithOptions:VLCMediaParseLocal|VLCMediaFetchLocal|VLCMediaParseNetwork|VLCMediaFetchNetwork];
187 |                  _player.media = media;
188 |             }
189 |             if(autoplay)
190 |                 [self play];
191 |             if(self.onVideoLoadStart){
192 |                 self.onVideoLoadStart(@{
193 |                                        @"target": self.reactTag
194 |                                      });
195 |             }
196 |         }
197 |     }
198 |     @catch(NSException *exception){
199 |           NSLog(@"%@", exception);
200 |     }
201 | }
202 | 
203 | - (void)mediaPlayerSnapshot:(NSNotification *)aNotification{
204 |      NSLog(@"userInfo %@",[aNotification userInfo]);
205 |     self.onSnapshot(@{
206 |                       @"target": self.reactTag,
207 |                       @"success": [NSNumber numberWithInt:1],
208 |                     });
209 | }
210 | 
211 | 
212 | - (void)mediaMetaDataDidChange:(VLCMedia *)aMedia{
213 |     NSLog(@"mediaMetaDataDidChange");
214 |     NSInteger readBytes = aMedia.numberOfReadBytesOnInput;
215 |     NSLog(@"readBytes %zd", readBytes);
216 |     BOOL isPlaying = _player.isPlaying;
217 |     BOOL hasVideoOut = _player.hasVideoOut;
218 |     self.onVideoStateChange(@{
219 |                               @"target": self.reactTag,
220 |                               @"isPlaying": [NSNumber numberWithBool: isPlaying],
221 |                               @"hasVideoOut": [NSNumber numberWithBool: hasVideoOut],
222 |                               @"type": @"mediaMetaDataDidChange",
223 |                             });
224 | }
225 | 
226 | - (void)mediaDidFinishParsing:(VLCMedia *)aMedia
227 | {
228 |     NSLog(@"mediaDidFinishParsing");
229 |     BOOL isPlaying = _player.isPlaying;
230 |     BOOL hasVideoOut = _player.hasVideoOut;
231 |     self.onVideoStateChange(@{
232 |                               @"target": self.reactTag,
233 |                               @"isPlaying": [NSNumber numberWithBool: isPlaying],
234 |                               @"hasVideoOut": [NSNumber numberWithBool: hasVideoOut],
235 |                               @"type": @"mediaDidFinishParsing",
236 |                             });
237 |     //NSLog(@"readBytes %zd", readBytes);
238 | }
239 | 
240 | - (void)mediaPlayerTimeChanged:(NSNotification *)aNotification
241 | {
242 |     [self updateVideoProgress];
243 | }
244 | 
245 | - (void)mediaPlayerStateChanged:(NSNotification *)aNotification
246 | {
247 |     @try{
248 |         if(_player){
249 | 
250 |             /*
251 |             NSInteger numberOfReadBytesOnInput = _player.media.numberOfReadBytesOnInput;
252 |             NSInteger numberOfPlayedAudioBuffers =  _player.media.numberOfPlayedAudioBuffers;
253 |             NSInteger numberOfSentBytes = _player.media.numberOfSentBytes;
254 |             NSInteger numberOfReadBytesOnDemux =  _player.media.numberOfReadBytesOnDemux;
255 |             NSInteger numberOfSentPackets =  _player.media.numberOfSentPackets;
256 |             NSInteger numberOfCorruptedDataPackets =  _player.media.numberOfCorruptedDataPackets;
257 |             NSInteger numberOfDisplayedPictures =  _player.media.numberOfDisplayedPictures;
258 |             NSInteger numberOfDecodedVideoBlocks =  _player.media.numberOfDecodedVideoBlocks;
259 |             */
260 |             VLCMediaPlayerState state = _player.state;
261 |             switch (state) {
262 |                 case VLCMediaPlayerStateOpening:
263 |                     self.onVideoStateChange(@{
264 |                                               @"target": self.reactTag,
265 |                                               @"type": @"Opening",
266 |                                               @"currentTime": [NSNumber numberWithInt:[[_player time] intValue]],
267 |                                               @"duration": [NSNumber numberWithInt:[_player.media.length intValue]]
268 |                                             });
269 |                     break;
270 |                 case VLCMediaPlayerStatePaused:
271 |                     _paused = YES;
272 |                     self.onVideoStateChange(@{
273 |                                               @"target": self.reactTag,
274 |                                               @"type": @"Paused",
275 |                                             });
276 |                     break;
277 |                 case VLCMediaPlayerStateStopped:
278 |                     self.onVideoStateChange(@{
279 |                                               @"target": self.reactTag,
280 |                                               @"type": @"Stoped",
281 |                                             });
282 |                     break;
283 |                 case VLCMediaPlayerStateBuffering:
284 |                     self.onVideoStateChange(@{
285 |                                               @"target": self.reactTag,
286 |                                               @"isBuffering": [NSNumber numberWithBool: !_player.isPlaying],
287 |                                               @"type": @"Buffering",
288 |                                             });
289 |                     break;
290 |                 case VLCMediaPlayerStatePlaying:
291 |                     _paused = NO;
292 |                     self.onVideoStateChange(@{
293 |                                               @"target": self.reactTag,
294 |                                               @"type": @"Playing",
295 |                                             });
296 |                     break;
297 |                 case VLCMediaPlayerStateESAdded:
298 |                     self.onVideoStateChange(@{
299 |                                               @"target": self.reactTag,
300 |                                               @"type": @"ESAdded",
301 |                                             });
302 |                     break;
303 |                 case VLCMediaPlayerStateEnded:
304 |                     NSLog(@"VLCMediaPlayerStateEnded %i",1);
305 |                     self.onVideoStateChange(@{
306 |                                               @"target": self.reactTag,
307 |                                               @"type": @"Ended",
308 |                                             });
309 |                     break;
310 |                 case VLCMediaPlayerStateError:
311 |                     self.onVideoStateChange(@{
312 |                                               @"target": self.reactTag,
313 |                                               @"type": @"Error",
314 |                                             });
315 |                     [self _release];
316 |                     break;
317 |             }
318 |         }
319 |     }@catch(NSException *exception){
320 |         NSLog(@"%@", exception);
321 |     }
322 | }
323 | 
324 | -(void)updateVideoProgress
325 | {   @try{
326 |         if(_player){
327 |             int currentTime  = [[_player time] intValue];
328 |             int duration     = [_player.media.length intValue];
329 | 
330 |             if( currentTime >= 0 && currentTime < duration) {
331 |                 self.onVideoProgress(@{
332 |                                        @"target": self.reactTag,
333 |                                        @"currentTime": [NSNumber numberWithInt:currentTime],
334 |                                        @"duration": [NSNumber numberWithInt:duration],
335 |                                      });
336 |             }
337 |         }
338 |     }
339 |     @catch(NSException *exception){
340 |         NSLog(@"%@", exception);
341 |     }
342 | }
343 | 
344 | - (void)jumpBackward:(int)interval
345 | {
346 |     if(interval>=0 && interval <= [_player.media.length intValue])
347 |         [_player jumpBackward:interval];
348 | }
349 | 
350 | - (void)jumpForward:(int)interval
351 | {
352 |     if(interval>=0 && interval <= [_player.media.length intValue])
353 |         [_player jumpForward:interval];
354 | }
355 | 
356 | /**
357 |  * audio  -----> start
358 |  */
359 | - (void)setMuted:(BOOL)muted
360 | {
361 |     if(_player){
362 |         VLCAudio *audio = _player.audio;
363 |         [audio setMuted: muted];
364 |     }
365 | }
366 | 
367 | -(void)setVolume:(int)interval
368 | {
369 |     if(_player){
370 |         VLCAudio *audio = _player.audio;
371 |         if(interval >= 0){
372 |             audio.volume = interval;
373 |         }
374 |     }
375 | }
376 | 
377 | -(void)setVolumeDown:(int)volume
378 | {
379 |     if(_player){
380 | 
381 |         VLCAudio *audio = _player.audio;
382 |         [audio volumeDown];
383 |     }
384 | }
385 | 
386 | 
387 | 
388 | -(void)setVolumeUp:(int)volume
389 | {
390 |     if(_player){
391 |         VLCAudio *audio = _player.audio;
392 |         [audio volumeUp];
393 |     }
394 | }
395 | 
396 | //audio  -----> end
397 | 
398 | 
399 | -(void)setSeekTime:(int)time{
400 |     if(_player){
401 |         float ms = time * 1000;
402 |         [_player setTime:[VLCTime timeWithInt:ms]];
403 | 
404 |         int currentTime  = [[_player time] intValue];
405 |         int duration     = [_player.media.length intValue];
406 |         self.onVideoSeek(@{
407 |                                @"target": self.reactTag,
408 |                                @"currentTime": [NSNumber numberWithInt:currentTime],
409 |                                @"duration": [NSNumber numberWithInt:duration],
410 |                              });
411 |     }
412 | }
413 | 
414 | -(void)setSnapshotPath:(NSString*)path
415 | {
416 |     if(_player)
417 |         [_player saveVideoSnapshotAt:path withWidth:0 andHeight:0];
418 | }
419 | 
420 | -(void)setRate:(float)rate
421 | {
422 |     [_player setRate:rate];
423 | }
424 | 
425 | -(void)setClear:(float)clear
426 | {
427 |     [self _release];
428 | }
429 | 
430 | 
431 | -(void)setVideoAspectRatio:(NSString *)ratio{
432 |     if(ratio != nil && ratio.length > 0){
433 |         char *char_content = [ratio cStringUsingEncoding:NSASCIIStringEncoding];
434 |         [_player setVideoAspectRatio:char_content];
435 |     }
436 | }
437 | 
438 | - (void)_release
439 | {
440 |     if(_player){
441 |         [_player stop];
442 |         _player = nil;
443 |         _eventDispatcher = nil;
444 |     }
445 |     [[NSNotificationCenter defaultCenter] removeObserver:self];
446 | }
447 | 
448 | - (void)dealloc{
449 |      [self _release];
450 | }
451 | #pragma mark - Lifecycle
452 | 
453 | //- (void)willMoveToSuperview:(UIView *)newSuperview
454 | //- (void)didMoveToSuperview
455 | 
456 | //- (void)willRemoveSubview:(UIView *)subview
457 | 
458 | 
459 | - (void)removeFromSuperview
460 | {
461 |     NSLog(@"removeFromSuperview");
462 |     [self _release];
463 |     [super removeFromSuperview];
464 | }
465 | 
466 | @end
467 | 


--------------------------------------------------------------------------------
/ios/RCTVLCPlayer/RCTVLCPlayerManager.h:
--------------------------------------------------------------------------------
1 | #import "React/RCTViewManager.h"
2 | 
3 | @interface RCTVLCPlayerManager : RCTViewManager
4 | 
5 | @end
6 | 


--------------------------------------------------------------------------------
/ios/RCTVLCPlayer/RCTVLCPlayerManager.m:
--------------------------------------------------------------------------------
 1 | #import "RCTVLCPlayerManager.h"
 2 | #import "RCTVLCPlayer.h"
 3 | #import "React/RCTBridge.h"
 4 | 
 5 | @implementation RCTVLCPlayerManager
 6 | 
 7 | RCT_EXPORT_MODULE();
 8 | 
 9 | @synthesize bridge = _bridge;
10 | 
11 | - (UIView *)view
12 | {
13 |     return [[RCTVLCPlayer alloc] initWithEventDispatcher:self.bridge.eventDispatcher];
14 | }
15 | 
16 | 
17 | - (dispatch_queue_t)methodQueue
18 | {
19 |     return dispatch_get_main_queue();
20 | }
21 | 
22 | RCT_EXPORT_VIEW_PROPERTY(source, NSDictionary);
23 | RCT_EXPORT_VIEW_PROPERTY(paused, BOOL);
24 | RCT_EXPORT_VIEW_PROPERTY(rate, float);
25 | RCT_EXPORT_VIEW_PROPERTY(muted, BOOL);
26 | RCT_EXPORT_VIEW_PROPERTY(volume, int);
27 | RCT_EXPORT_VIEW_PROPERTY(volumeUp, int);
28 | RCT_EXPORT_VIEW_PROPERTY(volumeDown, int);
29 | RCT_EXPORT_VIEW_PROPERTY(resume, BOOL);
30 | RCT_EXPORT_VIEW_PROPERTY(clear, BOOL);
31 | RCT_EXPORT_VIEW_PROPERTY(seekTime, int);
32 | RCT_EXPORT_VIEW_PROPERTY(videoAspectRatio, NSString);
33 | RCT_EXPORT_VIEW_PROPERTY(snapshotPath, NSString);
34 | /* Should support: onLoadStart, onLoad, and onError to stay consistent with Image */
35 | /*RCT_EXPORT_VIEW_PROPERTY(onVideoPaused, RCTDirectEventBlock);
36 |  RCT_EXPORT_VIEW_PROPERTY(onVideoStopped, RCTDirectEventBlock);
37 |  RCT_EXPORT_VIEW_PROPERTY(onVideoBuffering, RCTDirectEventBlock);
38 |  RCT_EXPORT_VIEW_PROPERTY(onVideoPlaying, RCTDirectEventBlock);
39 |  RCT_EXPORT_VIEW_PROPERTY(onVideoEnded, RCTDirectEventBlock);
40 |  RCT_EXPORT_VIEW_PROPERTY(onVideoError, RCTDirectEventBlock);
41 |  RCT_EXPORT_VIEW_PROPERTY(onVideoOpen, RCTDirectEventBlock);
42 |  */
43 | RCT_EXPORT_VIEW_PROPERTY(onVideoLoadStart, RCTDirectEventBlock);
44 | RCT_EXPORT_VIEW_PROPERTY(onVideoProgress, RCTDirectEventBlock);
45 | RCT_EXPORT_VIEW_PROPERTY(onVideoSeek, RCTDirectEventBlock);
46 | RCT_EXPORT_VIEW_PROPERTY(onSnapshot, RCTDirectEventBlock);
47 | RCT_EXPORT_VIEW_PROPERTY(onVideoStateChange, RCTDirectEventBlock);
48 | 
49 | 
50 | + (BOOL)requiresMainQueueSetup
51 | {
52 |     return YES;
53 | }
54 | 
55 | @end
56 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@lunarr/vlc-player",
 3 |   "version": "1.0.5",
 4 |   "description": "VLC Player for React Native",
 5 |   "main": "index.js",
 6 |   "scripts": {
 7 |     "test": "echo \"Error: no test specified\" && exit 1"
 8 |   },
 9 |   "keywords": [
10 |     "vlc",
11 |     "player",
12 |     "android",
13 |     "ios",
14 |     "react",
15 |     "native",
16 |     "video",
17 |     "x265",
18 |     "mkv",
19 |     "vp9",
20 |     "avc1",
21 |     "h264"
22 |   ],
23 |   "author": "Sayem Chowdhury",
24 |   "repository": {
25 |     "type": "git",
26 |     "url": "git+https://github.com/lunarr-app/vlc-player.git"
27 |   },
28 |   "license": "MIT",
29 |   "peerDependencies": {
30 |     "react": "*",
31 |     "react-native": "*"
32 |   },
33 |   "dependencies": {
34 |     "prop-types": "^15.8.1"
35 |   }
36 | }
37 | 


--------------------------------------------------------------------------------
/react-native-vlc-player.podspec:
--------------------------------------------------------------------------------
 1 | package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
 2 | 
 3 | Pod::Spec.new do |s|
 4 |   s.name            = 'react-native-vlc-player'
 5 |   s.version         = package['version']
 6 |   s.summary         = 'VLC Player for React Native'
 7 |   s.description     = package['description']
 8 |   s.author          = package['author']
 9 |   s.homepage        = package['repository']['url']
10 |   s.license         = package['license']
11 | 
12 |   s.platform        = :ios, '9.0'
13 |   s.source          = { git: 'https://github.com/lunarr-app/vlc-player.git', tag: 'master' }
14 |   s.preserve_paths  = 'ios/**/*'
15 |   s.source_files    = 'ios/**/*.{h,m}'
16 |   s.requires_arc    = true
17 |   # s.libraries           = 'bz2', 'iconv'
18 |   # s.framework           = 'AudioToolbox','AVFoundation', 'CFNetwork', 'CoreFoundation', 'CoreGraphics', 'CoreMedia', 'CoreText', 'CoreVideo', 'Foundation', 'OpenGLES', 'QuartzCore', 'Security', 'VideoToolbox', 'UIKit'
19 | 
20 |   s.dependency      'React'
21 |   s.dependency      'MobileVLCKit','~> 3.3.17'
22 | end
23 | 


--------------------------------------------------------------------------------
/yarn.lock:
--------------------------------------------------------------------------------
 1 | # THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
 2 | # yarn lockfile v1
 3 | 
 4 | 
 5 | "js-tokens@^3.0.0 || ^4.0.0":
 6 |   version "4.0.0"
 7 |   resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"
 8 |   integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==
 9 | 
10 | loose-envify@^1.4.0:
11 |   version "1.4.0"
12 |   resolved "https://registry.yarnpkg.com/loose-envify/-/loose-envify-1.4.0.tgz#71ee51fa7be4caec1a63839f7e682d8132d30caf"
13 |   integrity sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==
14 |   dependencies:
15 |     js-tokens "^3.0.0 || ^4.0.0"
16 | 
17 | object-assign@^4.1.1:
18 |   version "4.1.1"
19 |   resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
20 |   integrity sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=
21 | 
22 | prop-types@^15.8.1:
23 |   version "15.8.1"
24 |   resolved "https://registry.yarnpkg.com/prop-types/-/prop-types-15.8.1.tgz#67d87bf1a694f48435cf332c24af10214a3140b5"
25 |   integrity sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==
26 |   dependencies:
27 |     loose-envify "^1.4.0"
28 |     object-assign "^4.1.1"
29 |     react-is "^16.13.1"
30 | 
31 | react-is@^16.13.1:
32 |   version "16.13.1"
33 |   resolved "https://registry.yarnpkg.com/react-is/-/react-is-16.13.1.tgz#789729a4dc36de2999dc156dd6c1d9c18cea56a4"
34 |   integrity sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==
35 | 


--------------------------------------------------------------------------------