.
675 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # WebRtcCloudGame
2 | This is a cloud game demo based on WebRTC.
3 |
4 | ## WebRTC Live Streaming
5 |
6 | It is designed to demonstrate WebRTC screen share between androids and/or other clients.
7 | 
8 |
9 | ## How To
10 | You need [ProjectRTC](https://github.com/pchab/ProjectRTC) up and running, and it must be somewhere that your android can access. (You can quickly test this with your android browser). Modify the host string (in res/values/strings.xml) to the server IP.
11 |
12 |
13 | Your stream should appear as "cloud_phone_stream" in ProjectRTC, so you can also use the view feature there.
14 |
--------------------------------------------------------------------------------
/app/.gitignore:
--------------------------------------------------------------------------------
1 | /build
2 |
--------------------------------------------------------------------------------
/app/build.gradle:
--------------------------------------------------------------------------------
1 | apply plugin: 'com.android.application'
2 |
3 | android {
4 | compileSdkVersion 29
5 | buildToolsVersion "29.0.2"
6 | defaultConfig {
7 | applicationId "com.example.webrtccloudgame"
8 | minSdkVersion 19
9 | targetSdkVersion 29
10 | versionCode 1
11 | versionName "1.0"
12 | testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
13 | }
14 | buildTypes {
15 | release {
16 | minifyEnabled false
17 | proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
18 | }
19 | }
20 | compileOptions {
21 | sourceCompatibility = 1.8
22 | targetCompatibility = 1.8
23 | }
24 | }
25 |
26 | dependencies {
27 | implementation fileTree(dir: 'libs', include: ['*.jar'])
28 | implementation 'androidx.appcompat:appcompat:1.0.2'
29 | testImplementation 'junit:junit:4.12'
30 | androidTestImplementation 'androidx.test:runner:1.1.1'
31 | androidTestImplementation 'androidx.test.espresso:espresso-core:3.1.1'
32 |
33 | implementation ('io.socket:socket.io-client:1.0.0') {
34 | // excluding org.json which is provided by Android
35 | exclude group: 'org.json', module: 'json'
36 | }
37 | implementation 'org.webrtc:google-webrtc:1.0.21217'
38 | }
39 |
--------------------------------------------------------------------------------
/app/proguard-rules.pro:
--------------------------------------------------------------------------------
1 | # Add project specific ProGuard rules here.
2 | # You can control the set of applied configuration files using the
3 | # proguardFiles setting in build.gradle.
4 | #
5 | # For more details, see
6 | # http://developer.android.com/guide/developing/tools/proguard.html
7 |
8 | # If your project uses WebView with JS, uncomment the following
9 | # and specify the fully qualified class name to the JavaScript interface
10 | # class:
11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
12 | # public *;
13 | #}
14 |
15 | # Uncomment this to preserve the line number information for
16 | # debugging stack traces.
17 | #-keepattributes SourceFile,LineNumberTable
18 |
19 | # If you keep the line number information, uncomment this to
20 | # hide the original source file name.
21 | #-renamesourcefileattribute SourceFile
22 |
--------------------------------------------------------------------------------
/app/src/androidTest/java/com/example/webrtccloudgame/ExampleInstrumentedTest.java:
--------------------------------------------------------------------------------
1 | package com.example.webrtccloudgame;
2 |
3 | import android.content.Context;
4 |
5 | import androidx.test.platform.app.InstrumentationRegistry;
6 | import androidx.test.runner.AndroidJUnit4;
7 |
8 | import org.junit.Test;
9 | import org.junit.runner.RunWith;
10 |
11 | import static org.junit.Assert.assertEquals;
12 |
13 | /**
14 | * Instrumented test, which will execute on an Android device.
15 | *
16 | * @see Testing documentation
17 | */
18 | @RunWith(AndroidJUnit4.class)
19 | public class ExampleInstrumentedTest {
20 | @Test
21 | public void useAppContext() {
22 | // Context of the app under test.
23 | Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
24 |
25 | assertEquals("com.joygames.com.example.webrtccloudgame", appContext.getPackageName());
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/app/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
7 |
8 |
9 |
10 |
11 |
19 |
20 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
--------------------------------------------------------------------------------
/app/src/main/java/com/example/webrtccloudgame/ClientActivity.java:
--------------------------------------------------------------------------------
1 | package com.example.webrtccloudgame;
2 |
3 | import android.app.Activity;
4 | import android.os.Bundle;
5 | import android.util.DisplayMetrics;
6 | import android.util.Log;
7 | import android.view.Window;
8 | import android.view.WindowManager;
9 | import android.widget.Toast;
10 |
11 | import androidx.annotation.Nullable;
12 |
13 | import org.json.JSONException;
14 | import org.webrtc.EglBase;
15 | import org.webrtc.Logging;
16 | import org.webrtc.MediaStream;
17 | import org.webrtc.RendererCommon;
18 | import org.webrtc.SurfaceViewRenderer;
19 | import org.webrtc.VideoRenderer;
20 | import org.webrtc.VideoTrack;
21 |
22 | public class ClientActivity extends Activity implements WebRtcClient.RtcListener {
23 |
24 | private static final String TAG = ClientActivity.class.getCanonicalName();
25 |
26 | private WebRtcClient mWebRtcClient;
27 | private String cloudPhoneSocketId = "EUZWeNA1G4yCPrkDAABl";
28 |
29 | private EglBase eglBase = EglBase.create();
30 | private SurfaceViewRenderer fullscreenRenderer;
31 | private ProxyRenderer remoteProxyRenderer = new ProxyRenderer();
32 |
33 | private static final String[] MANDATORY_PERMISSIONS = {"android.permission.INTERNET"};
34 | protected PermissionChecker permissionChecker = new PermissionChecker();
35 |
36 | public static int sDeviceWidth;
37 | public static int sDeviceHeight;
38 | public static final int SCREEN_RESOLUTION_SCALE = 2;
39 |
40 | @Override
41 | protected void onCreate(@Nullable Bundle savedInstanceState) {
42 | super.onCreate(savedInstanceState);
43 | requestWindowFeature(Window.FEATURE_NO_TITLE);
44 | getWindow().addFlags(
45 | WindowManager.LayoutParams.FLAG_FULLSCREEN
46 | | WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
47 | | WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD
48 | | WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED
49 | | WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON);
50 | setContentView(R.layout.activity_client);
51 |
52 | DisplayMetrics metrics = new DisplayMetrics();
53 | getWindowManager().getDefaultDisplay().getRealMetrics(metrics);
54 | sDeviceWidth = metrics.widthPixels;
55 | sDeviceHeight = metrics.heightPixels;
56 |
57 | fullscreenRenderer = findViewById(R.id.fullscreen_video_view);
58 | fullscreenRenderer.setKeepScreenOn(true);
59 | fullscreenRenderer.init(eglBase.getEglBaseContext(), null);
60 | fullscreenRenderer.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FILL);
61 | fullscreenRenderer.setEnableHardwareScaler(true);
62 | remoteProxyRenderer.setTarget(fullscreenRenderer);
63 |
64 | checkPermissions();
65 | init();
66 | }
67 |
68 | private void checkPermissions() {
69 | permissionChecker.verifyPermissions(this, MANDATORY_PERMISSIONS, new PermissionChecker.VerifyPermissionsCallback() {
70 |
71 | @Override
72 | public void onPermissionAllGranted() {
73 |
74 | }
75 |
76 | @Override
77 | public void onPermissionDeny(String[] permissions) {
78 | Toast.makeText(ClientActivity.this, "Please grant required permissions.", Toast.LENGTH_LONG).show();
79 | }
80 | });
81 | }
82 |
83 | private void init() {
84 | PeerConnectionClient.PeerConnectionParameters peerConnectionParameters =
85 | new PeerConnectionClient.PeerConnectionParameters(
86 | true,
87 | false,
88 | true,
89 | sDeviceWidth / SCREEN_RESOLUTION_SCALE,
90 | sDeviceHeight / SCREEN_RESOLUTION_SCALE,
91 | 30,
92 | 0,
93 | "VP9",
94 | true,
95 | true,
96 | 0,
97 | "OPUS",
98 | false,
99 | false,
100 | false,
101 | false,
102 | false,
103 | false,
104 | false,
105 | false,
106 | null);
107 | mWebRtcClient = new WebRtcClient(getApplicationContext(), eglBase, peerConnectionParameters, this, null);
108 | }
109 |
110 | public void answer(String callerId) throws JSONException {
111 | mWebRtcClient.sendMessage(callerId, "init", null);
112 | }
113 |
114 | @Override
115 | public void onReady(String socketId) {
116 | try {
117 | answer(cloudPhoneSocketId);
118 | } catch (JSONException e) {
119 | e.printStackTrace();
120 | }
121 | }
122 |
123 | @Override
124 | public void onStatusChanged(String newStatus) {
125 | }
126 |
127 | @Override
128 | public void onAddLocalStream(MediaStream localStream) {
129 | }
130 |
131 | @Override
132 | public void onAddRemoteStream(MediaStream remoteStream, int endPoint) {
133 | if (remoteStream.videoTracks.size() == 1) {
134 | Log.d(TAG, "onAddRemoteStream");
135 | VideoTrack remoteVideoTrack = remoteStream.videoTracks.get(0);
136 | remoteVideoTrack.setEnabled(true);
137 | remoteVideoTrack.addRenderer(new VideoRenderer(remoteProxyRenderer));
138 | }
139 | }
140 |
141 | @Override
142 | public void onRemoveRemoteStream(int endPoint) {
143 | }
144 |
145 | private static class ProxyRenderer implements VideoRenderer.Callbacks {
146 | private VideoRenderer.Callbacks target;
147 |
148 | @Override
149 | synchronized public void renderFrame(VideoRenderer.I420Frame frame) {
150 | if (target == null) {
151 | Logging.d(TAG, "Dropping frame in proxy because target is null.");
152 | VideoRenderer.renderFrameDone(frame);
153 | return;
154 | }
155 |
156 | target.renderFrame(frame);
157 | }
158 |
159 | synchronized public void setTarget(VideoRenderer.Callbacks target) {
160 | this.target = target;
161 | }
162 | }
163 | }
164 |
--------------------------------------------------------------------------------
/app/src/main/java/com/example/webrtccloudgame/CloudPhoneActivity.java:
--------------------------------------------------------------------------------
1 | package com.example.webrtccloudgame;
2 |
3 | import android.annotation.TargetApi;
4 | import android.app.Activity;
5 | import android.content.Context;
6 | import android.content.Intent;
7 | import android.media.projection.MediaProjection;
8 | import android.media.projection.MediaProjectionManager;
9 | import android.os.Build;
10 | import android.os.Bundle;
11 | import android.util.DisplayMetrics;
12 | import android.util.Log;
13 | import android.view.Window;
14 | import android.view.WindowManager;
15 | import android.widget.Toast;
16 |
17 | import org.webrtc.EglBase;
18 | import org.webrtc.MediaStream;
19 | import org.webrtc.ScreenCapturerAndroid;
20 | import org.webrtc.VideoCapturer;
21 |
22 | public class CloudPhoneActivity extends Activity implements WebRtcClient.RtcListener {
23 |
24 | private static final String TAG = CloudPhoneActivity.class.getCanonicalName();
25 |
26 | private WebRtcClient mWebRtcClient;
27 |
28 | private static final int CAPTURE_PERMISSION_REQUEST_CODE = 1116;
29 | private static Intent mMediaProjectionPermissionResultData;
30 | private static int mMediaProjectionPermissionResultCode;
31 |
32 | private static final String STREAM_NAME_PREFIX = "cloud_phone_stream";
33 | private static final String[] MANDATORY_PERMISSIONS = {"android.permission.INTERNET"};
34 | protected PermissionChecker permissionChecker = new PermissionChecker();
35 |
36 | public static int sDeviceWidth;
37 | public static int sDeviceHeight;
38 | public static final int SCREEN_RESOLUTION_SCALE = 2;
39 |
40 | @Override
41 | public void onCreate(Bundle savedInstanceState) {
42 | super.onCreate(savedInstanceState);
43 | requestWindowFeature(Window.FEATURE_NO_TITLE);
44 | getWindow().addFlags(
45 | WindowManager.LayoutParams.FLAG_FULLSCREEN
46 | | WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
47 | | WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD
48 | | WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED
49 | | WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON);
50 | setContentView(R.layout.activity_cloud_phone);
51 |
52 | DisplayMetrics metrics = new DisplayMetrics();
53 | getWindowManager().getDefaultDisplay().getRealMetrics(metrics);
54 | sDeviceWidth = metrics.widthPixels;
55 | sDeviceHeight = metrics.heightPixels;
56 |
57 | checkPermissions();
58 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
59 | startScreenCapture();
60 | } else {
61 | init();
62 | }
63 | }
64 |
65 | private void checkPermissions() {
66 | permissionChecker.verifyPermissions(this, MANDATORY_PERMISSIONS, new PermissionChecker.VerifyPermissionsCallback() {
67 |
68 | @Override
69 | public void onPermissionAllGranted() {
70 |
71 | }
72 |
73 | @Override
74 | public void onPermissionDeny(String[] permissions) {
75 | Toast.makeText(CloudPhoneActivity.this, "Please grant required permissions.", Toast.LENGTH_LONG).show();
76 | }
77 | });
78 | }
79 |
80 | @TargetApi(21)
81 | private void startScreenCapture() {
82 | MediaProjectionManager mediaProjectionManager =
83 | (MediaProjectionManager) getApplication().getSystemService(
84 | Context.MEDIA_PROJECTION_SERVICE);
85 | startActivityForResult(
86 | mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE);
87 | }
88 |
89 | @TargetApi(21)
90 | private VideoCapturer createScreenCapturer() {
91 | if (mMediaProjectionPermissionResultCode != Activity.RESULT_OK) {
92 | Log.e(TAG, "User didn't give permission to capture the screen.");
93 | return null;
94 | }
95 | return new ScreenCapturerAndroid(
96 | mMediaProjectionPermissionResultData, new MediaProjection.Callback() {
97 | @Override
98 | public void onStop() {
99 | Log.e(TAG, "User revoked permission to capture the screen.");
100 | }
101 | });
102 | }
103 |
104 | @Override
105 | public void onActivityResult(int requestCode, int resultCode, Intent data) {
106 | if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE)
107 | return;
108 | mMediaProjectionPermissionResultCode = resultCode;
109 | mMediaProjectionPermissionResultData = data;
110 | init();
111 | }
112 |
113 | private void init() {
114 | PeerConnectionClient.PeerConnectionParameters peerConnectionParameters =
115 | new PeerConnectionClient.PeerConnectionParameters(
116 | true,
117 | false,
118 | true,
119 | sDeviceWidth / SCREEN_RESOLUTION_SCALE,
120 | sDeviceHeight / SCREEN_RESOLUTION_SCALE,
121 | 30,
122 | 0,
123 | "VP9",
124 | true,
125 | true,
126 | 0,
127 | "OPUS",
128 | false,
129 | false,
130 | false,
131 | false,
132 | false,
133 | false,
134 | false,
135 | false,
136 | null);
137 | mWebRtcClient = new WebRtcClient(getApplicationContext(), EglBase.create(), peerConnectionParameters, this, createScreenCapturer());
138 | }
139 |
140 | @Override
141 | public void onDestroy() {
142 | if (mWebRtcClient != null) {
143 | mWebRtcClient.destroy();
144 | }
145 | super.onDestroy();
146 | }
147 |
148 | @Override
149 | public void onReady(String socketId) {
150 | Log.d(TAG, "On ready, callId = " + socketId);
151 | mWebRtcClient.start(STREAM_NAME_PREFIX);
152 | }
153 |
154 | @Override
155 | public void onStatusChanged(final String newStatus) {
156 | runOnUiThread(new Runnable() {
157 | @Override
158 | public void run() {
159 | Toast.makeText(getApplicationContext(), newStatus, Toast.LENGTH_SHORT).show();
160 | }
161 | });
162 | }
163 |
164 | @Override
165 | public void onAddLocalStream(MediaStream localStream) {
166 |
167 | }
168 |
169 | @Override
170 | public void onAddRemoteStream(MediaStream remoteStream, int endPoint) {
171 |
172 | }
173 |
174 | @Override
175 | public void onRemoveRemoteStream(int endPoint) {
176 |
177 | }
178 |
179 | }
180 |
--------------------------------------------------------------------------------
/app/src/main/java/com/example/webrtccloudgame/PeerConnectionClient.java:
--------------------------------------------------------------------------------
1 | package com.example.webrtccloudgame;
2 |
3 | /**
4 | * Peer connection client implementation.
5 | *
6 | *
All public methods are routed to local looper thread.
7 | * All PeerConnectionEvents callbacks are invoked from the same looper thread.
8 | * This class is a singleton.
9 | */
10 | public class PeerConnectionClient {
11 |
12 | /**
13 | * Data channel parameters.
14 | */
15 | public static class DataChannelParameters {
16 | public final boolean ordered;
17 | public final int maxRetransmitTimeMs;
18 | public final int maxRetransmits;
19 | public final String protocol;
20 | public final boolean negotiated;
21 | public final int id;
22 |
23 | public DataChannelParameters(boolean ordered, int maxRetransmitTimeMs, int maxRetransmits,
24 | String protocol, boolean negotiated, int id) {
25 | this.ordered = ordered;
26 | this.maxRetransmitTimeMs = maxRetransmitTimeMs;
27 | this.maxRetransmits = maxRetransmits;
28 | this.protocol = protocol;
29 | this.negotiated = negotiated;
30 | this.id = id;
31 | }
32 | }
33 |
34 | /**
35 | * Peer connection parameters.
36 | */
37 | public static class PeerConnectionParameters {
38 | public final boolean videoCallEnabled;
39 | public final boolean loopback;
40 | public final boolean tracing;
41 | public final int videoWidth;
42 | public final int videoHeight;
43 | public final int videoFps;
44 | public final int videoMaxBitrate;
45 | public final String videoCodec;
46 | public final boolean videoCodecHwAcceleration;
47 | public final boolean videoFlexfecEnabled;
48 | public final int audioStartBitrate;
49 | public final String audioCodec;
50 | public final boolean noAudioProcessing;
51 | public final boolean aecDump;
52 | public final boolean useOpenSLES;
53 | public final boolean disableBuiltInAEC;
54 | public final boolean disableBuiltInAGC;
55 | public final boolean disableBuiltInNS;
56 | public final boolean enableLevelControl;
57 | public final boolean disableWebRtcAGCAndHPF;
58 | private final DataChannelParameters dataChannelParameters;
59 |
60 | public PeerConnectionParameters(boolean videoCallEnabled, boolean loopback, boolean tracing,
61 | int videoWidth, int videoHeight, int videoFps, int videoMaxBitrate, String videoCodec,
62 | boolean videoCodecHwAcceleration, boolean videoFlexfecEnabled, int audioStartBitrate,
63 | String audioCodec, boolean noAudioProcessing, boolean aecDump, boolean useOpenSLES,
64 | boolean disableBuiltInAEC, boolean disableBuiltInAGC, boolean disableBuiltInNS,
65 | boolean enableLevelControl, boolean disableWebRtcAGCAndHPF) {
66 | this(videoCallEnabled, loopback, tracing, videoWidth, videoHeight, videoFps, videoMaxBitrate,
67 | videoCodec, videoCodecHwAcceleration, videoFlexfecEnabled, audioStartBitrate, audioCodec,
68 | noAudioProcessing, aecDump, useOpenSLES, disableBuiltInAEC, disableBuiltInAGC,
69 | disableBuiltInNS, enableLevelControl, disableWebRtcAGCAndHPF, null);
70 | }
71 |
72 | public PeerConnectionParameters(boolean videoCallEnabled, boolean loopback, boolean tracing,
73 | int videoWidth, int videoHeight, int videoFps, int videoMaxBitrate, String videoCodec,
74 | boolean videoCodecHwAcceleration, boolean videoFlexfecEnabled, int audioStartBitrate,
75 | String audioCodec, boolean noAudioProcessing, boolean aecDump, boolean useOpenSLES,
76 | boolean disableBuiltInAEC, boolean disableBuiltInAGC, boolean disableBuiltInNS,
77 | boolean enableLevelControl, boolean disableWebRtcAGCAndHPF,
78 | DataChannelParameters dataChannelParameters) {
79 | this.videoCallEnabled = videoCallEnabled;
80 | this.loopback = loopback;
81 | this.tracing = tracing;
82 | this.videoWidth = videoWidth;
83 | this.videoHeight = videoHeight;
84 | this.videoFps = videoFps;
85 | this.videoMaxBitrate = videoMaxBitrate;
86 | this.videoCodec = videoCodec;
87 | this.videoFlexfecEnabled = videoFlexfecEnabled;
88 | this.videoCodecHwAcceleration = videoCodecHwAcceleration;
89 | this.audioStartBitrate = audioStartBitrate;
90 | this.audioCodec = audioCodec;
91 | this.noAudioProcessing = noAudioProcessing;
92 | this.aecDump = aecDump;
93 | this.useOpenSLES = useOpenSLES;
94 | this.disableBuiltInAEC = disableBuiltInAEC;
95 | this.disableBuiltInAGC = disableBuiltInAGC;
96 | this.disableBuiltInNS = disableBuiltInNS;
97 | this.enableLevelControl = enableLevelControl;
98 | this.disableWebRtcAGCAndHPF = disableWebRtcAGCAndHPF;
99 | this.dataChannelParameters = dataChannelParameters;
100 | }
101 | }
102 |
103 | }
104 |
--------------------------------------------------------------------------------
/app/src/main/java/com/example/webrtccloudgame/PermissionChecker.java:
--------------------------------------------------------------------------------
1 | package com.example.webrtccloudgame;
2 |
3 | import android.app.Activity;
4 | import android.content.Context;
5 | import android.content.pm.PackageManager;
6 |
7 | import androidx.annotation.NonNull;
8 | import androidx.core.app.ActivityCompat;
9 |
10 | import java.util.ArrayList;
11 |
12 | public class PermissionChecker {
13 |
14 | private final int REQUEST_MULTIPLE_PERMISSION = 100;
15 | private VerifyPermissionsCallback callbackMultiple;
16 |
17 | public void verifyPermissions(Activity activity, @NonNull String[] permissions, VerifyPermissionsCallback callback) {
18 | String[] denyPermissions = getDenyPermissions(activity, permissions);
19 | if (denyPermissions.length > 0) {
20 | ActivityCompat.requestPermissions(activity, denyPermissions, REQUEST_MULTIPLE_PERMISSION);
21 | this.callbackMultiple = callback;
22 | } else {
23 | if (callback != null) {
24 | callback.onPermissionAllGranted();
25 | }
26 | }
27 | }
28 |
29 | private String[] getDenyPermissions(@NonNull Context context, @NonNull String[] permissions) {
30 | ArrayList denyPermissions = new ArrayList<>();
31 | for (String permission : permissions) {
32 | if (ActivityCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) {
33 | denyPermissions.add(permission);
34 | }
35 | }
36 | return denyPermissions.toArray(new String[0]);
37 | }
38 |
39 | public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
40 | switch (requestCode) {
41 | case REQUEST_MULTIPLE_PERMISSION:
42 | if (grantResults.length > 0 && callbackMultiple != null) {
43 | ArrayList denyPermissions = new ArrayList<>();
44 | int i = 0;
45 | for (String permission : permissions) {
46 | if (grantResults[i] == PackageManager.PERMISSION_DENIED) {
47 | denyPermissions.add(permission);
48 | }
49 | i++;
50 | }
51 | if (denyPermissions.size() == 0) {
52 | callbackMultiple.onPermissionAllGranted();
53 | } else {
54 | callbackMultiple.onPermissionDeny(denyPermissions.toArray(new String[0]));
55 | }
56 | }
57 | break;
58 | }
59 | }
60 |
61 | public static boolean hasPermissions(@NonNull Context context, @NonNull String[] permissions) {
62 | for (String permission : permissions) {
63 | if (ActivityCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) {
64 | return false;
65 | }
66 | }
67 | return true;
68 | }
69 |
70 | public interface VerifyPermissionsCallback {
71 | void onPermissionAllGranted();
72 |
73 | void onPermissionDeny(String[] permissions);
74 | }
75 | }
76 |
--------------------------------------------------------------------------------
/app/src/main/java/com/example/webrtccloudgame/WebRtcClient.java:
--------------------------------------------------------------------------------
1 | package com.example.webrtccloudgame;
2 |
3 | import android.content.Context;
4 | import android.util.Log;
5 |
6 | import org.json.JSONException;
7 | import org.json.JSONObject;
8 | import org.webrtc.DataChannel;
9 | import org.webrtc.DefaultVideoDecoderFactory;
10 | import org.webrtc.DefaultVideoEncoderFactory;
11 | import org.webrtc.EglBase;
12 | import org.webrtc.IceCandidate;
13 | import org.webrtc.MediaConstraints;
14 | import org.webrtc.MediaStream;
15 | import org.webrtc.PeerConnection;
16 | import org.webrtc.PeerConnectionFactory;
17 | import org.webrtc.RtpReceiver;
18 | import org.webrtc.SdpObserver;
19 | import org.webrtc.SessionDescription;
20 | import org.webrtc.VideoCapturer;
21 | import org.webrtc.VideoSource;
22 | import org.webrtc.VideoTrack;
23 |
24 | import java.net.URISyntaxException;
25 | import java.util.HashMap;
26 | import java.util.LinkedList;
27 |
28 | import io.socket.client.IO;
29 | import io.socket.client.Socket;
30 | import io.socket.emitter.Emitter;
31 |
32 | public class WebRtcClient {
33 |
34 | private static final String TAG = WebRtcClient.class.getCanonicalName();
35 | private static final String VIDEO_TRACK_ID = "ARDAMSv0";
36 |
37 | private Context mContext;
38 | private EglBase mRootEglBase;
39 | private Socket mSocket;
40 | private MessageHandler messageHandler = new MessageHandler();
41 |
42 | private static final int MAX_PEER = 2;
43 | private boolean[] endPoints = new boolean[MAX_PEER];
44 | private HashMap peers = new HashMap<>();
45 | private PeerConnectionFactory factory;
46 |
47 | private LinkedList iceServers = new LinkedList<>();
48 | private PeerConnectionClient.PeerConnectionParameters mPeerConnParams;
49 | private MediaConstraints mPeerConnConstraints = new MediaConstraints();
50 | private MediaStream mLocalMediaStream;
51 | private VideoSource mVideoSource;
52 | private RtcListener mListener;
53 | private VideoCapturer videoCapturer;
54 |
55 | /**
56 | * Implement this interface to be notified of events.
57 | */
58 | public interface RtcListener {
59 | void onReady(String socketId);
60 |
61 | void onStatusChanged(String newStatus);
62 |
63 | void onAddLocalStream(MediaStream localStream);
64 |
65 | void onAddRemoteStream(MediaStream remoteStream, int endPoint);
66 |
67 | void onRemoveRemoteStream(int endPoint);
68 | }
69 |
70 | public interface Command {
71 | void execute(String peerId, JSONObject payload) throws JSONException;
72 | }
73 |
74 | public class CreateOfferCommand implements Command {
75 | public void execute(String peerId, JSONObject payload) {
76 | Peer peer = peers.get(peerId);
77 | peer.pc.createOffer(peer, mPeerConnConstraints);
78 | }
79 | }
80 |
81 | public class CreateAnswerCommand implements Command {
82 | public void execute(String peerId, JSONObject payload) {
83 | Peer peer = peers.get(peerId);
84 | SessionDescription sdp = new SessionDescription(
85 | SessionDescription.Type.fromCanonicalForm(payload.optString("type")),
86 | payload.optString("sdp")
87 | );
88 | peer.pc.setRemoteDescription(peer, sdp);
89 | peer.pc.createAnswer(peer, mPeerConnConstraints);
90 | }
91 | }
92 |
93 | public class SetRemoteSDPCommand implements Command {
94 | public void execute(String peerId, JSONObject payload) {
95 | Peer peer = peers.get(peerId);
96 | SessionDescription sdp = new SessionDescription(
97 | SessionDescription.Type.fromCanonicalForm(payload.optString("type")),
98 | payload.optString("sdp")
99 | );
100 | peer.pc.setRemoteDescription(peer, sdp);
101 | }
102 | }
103 |
104 | public class AddIceCandidateCommand implements Command {
105 | public void execute(String peerId, JSONObject payload) {
106 | PeerConnection pc = peers.get(peerId).pc;
107 | if (pc.getRemoteDescription() != null) {
108 | IceCandidate candidate = new IceCandidate(
109 | payload.optString("id"),
110 | payload.optInt("label"),
111 | payload.optString("candidate")
112 | );
113 | pc.addIceCandidate(candidate);
114 | }
115 | }
116 | }
117 |
118 | /**
119 | * Send a message through the signaling server
120 | *
121 | * @param to id of recipient
122 | * @param type type of message
123 | * @param payload payload of message
124 | * @throws JSONException
125 | */
126 | public void sendMessage(String to, String type, JSONObject payload) throws JSONException {
127 | JSONObject message = new JSONObject();
128 | message.put("to", to);
129 | message.put("type", type);
130 | message.put("payload", payload);
131 | mSocket.emit("message", message);
132 | Log.d(TAG, "socket send " + type + " to " + to + " payload:" + payload);
133 | }
134 |
135 | public class MessageHandler {
136 | private HashMap commandMap;
137 |
138 | public MessageHandler() {
139 | this.commandMap = new HashMap<>();
140 | commandMap.put("init", new CreateOfferCommand());
141 | commandMap.put("offer", new CreateAnswerCommand());
142 | commandMap.put("answer", new SetRemoteSDPCommand());
143 | commandMap.put("candidate", new AddIceCandidateCommand());
144 | }
145 |
146 | public Emitter.Listener onMessage = new Emitter.Listener() {
147 | @Override
148 | public void call(Object... args) {
149 | try {
150 | JSONObject data = (JSONObject) args[0];
151 | String from = data.optString("from");
152 | String type = data.optString("type");
153 | Log.d(TAG, "socket received " + type + " from " + from);
154 | JSONObject payload = null;
155 | if (!type.equals("init")) {
156 | payload = data.optJSONObject("payload");
157 | }
158 | // if peer is unknown, try to add him
159 | if (!peers.containsKey(from)) {
160 | // if MAX_PEER is reach, ignore the call
161 | int endPoint = findEndPoint();
162 | if (endPoint != MAX_PEER) {
163 | Peer peer = addPeer(from, endPoint);
164 | if (mLocalMediaStream != null) {
165 | peer.pc.addStream(mLocalMediaStream);
166 | }
167 | commandMap.get(type).execute(from, payload);
168 | }
169 | } else {
170 | Command command = commandMap.get(type);
171 | if (command != null) {
172 | command.execute(from, payload);
173 | }
174 | }
175 | } catch (JSONException e) {
176 | e.printStackTrace();
177 | }
178 | }
179 | };
180 |
181 | public Emitter.Listener onId = new Emitter.Listener() {
182 | @Override
183 | public void call(Object... args) {
184 | String id = (String) args[0];
185 | mListener.onReady(id);
186 | mListener.onStatusChanged("READY");
187 | }
188 | };
189 | }
190 |
191 | public class Peer implements SdpObserver, PeerConnection.Observer {
192 | public PeerConnection pc;
193 | public String id;
194 | public int endPoint;
195 |
196 | public Peer(String id, int endPoint) {
197 | Log.d(TAG, "new Peer: " + id + " " + endPoint);
198 | this.pc = factory.createPeerConnection(iceServers, mPeerConnConstraints, this);
199 | this.id = id;
200 | this.endPoint = endPoint;
201 | if (mLocalMediaStream != null) {
202 | pc.addStream(mLocalMediaStream);
203 | }
204 | }
205 |
206 | @Override
207 | public void onSignalingChange(PeerConnection.SignalingState signalingState) {
208 | }
209 |
210 | @Override
211 | public void onIceConnectionChange(PeerConnection.IceConnectionState iceConnectionState) {
212 | if (iceConnectionState == PeerConnection.IceConnectionState.DISCONNECTED) {
213 | removePeer(id);
214 | mListener.onStatusChanged("DISCONNECTED");
215 | }
216 | }
217 |
218 | @Override
219 | public void onIceConnectionReceivingChange(boolean b) {
220 | }
221 |
222 | @Override
223 | public void onIceGatheringChange(PeerConnection.IceGatheringState iceGatheringState) {
224 | }
225 |
226 | @Override
227 | public void onIceCandidate(IceCandidate iceCandidate) {
228 | try {
229 | JSONObject payload = new JSONObject();
230 | payload.put("label", iceCandidate.sdpMLineIndex);
231 | payload.put("id", iceCandidate.sdpMid);
232 | payload.put("candidate", iceCandidate.sdp);
233 | sendMessage(id, "candidate", payload);
234 | } catch (JSONException e) {
235 | e.printStackTrace();
236 | }
237 | }
238 |
239 | @Override
240 | public void onIceCandidatesRemoved(IceCandidate[] iceCandidates) {
241 | }
242 |
243 | @Override
244 | public void onAddStream(MediaStream mediaStream) {
245 | mListener.onAddRemoteStream(mediaStream, endPoint + 1);
246 | }
247 |
248 | @Override
249 | public void onRemoveStream(MediaStream mediaStream) {
250 | removePeer(id);
251 | }
252 |
253 | @Override
254 | public void onDataChannel(DataChannel dataChannel) {
255 | }
256 |
257 | @Override
258 | public void onRenegotiationNeeded() {
259 | }
260 |
261 | @Override
262 | public void onAddTrack(RtpReceiver rtpReceiver, MediaStream[] mediaStreams) {
263 | }
264 |
265 |
266 | @Override
267 | public void onCreateSuccess(SessionDescription sessionDescription) {
268 | try {
269 | JSONObject payload = new JSONObject();
270 | payload.put("type", sessionDescription.type.canonicalForm());
271 | payload.put("sdp", sessionDescription.description);
272 | sendMessage(id, sessionDescription.type.canonicalForm(), payload);
273 | pc.setLocalDescription(Peer.this, sessionDescription);
274 | } catch (JSONException e) {
275 | e.printStackTrace();
276 | }
277 | }
278 |
279 | @Override
280 | public void onSetSuccess() {
281 | }
282 |
283 | @Override
284 | public void onCreateFailure(String s) {
285 | }
286 |
287 | @Override
288 | public void onSetFailure(String s) {
289 | }
290 | }
291 |
292 | private Peer addPeer(String id, int endPoint) {
293 | Peer peer = new Peer(id, endPoint);
294 | peers.put(id, peer);
295 |
296 | endPoints[endPoint] = true;
297 | return peer;
298 | }
299 |
300 | private void removePeer(String id) {
301 | Peer peer = peers.get(id);
302 | peer.pc.close();
303 | peers.remove(peer.id);
304 | endPoints[peer.endPoint] = false;
305 | }
306 |
307 | public WebRtcClient(Context context, EglBase eglBase, PeerConnectionClient.PeerConnectionParameters params, RtcListener listener, VideoCapturer capturer) {
308 | mContext = context;
309 | mRootEglBase = eglBase;
310 | mPeerConnParams = params;
311 | mListener = listener;
312 | videoCapturer = capturer;
313 |
314 | PeerConnectionFactory.initialize(
315 | PeerConnectionFactory.InitializationOptions.builder(mContext)
316 | .setEnableInternalTracer(true)
317 | .createInitializationOptions());
318 | factory = new PeerConnectionFactory(new PeerConnectionFactory.Options(),
319 | new DefaultVideoEncoderFactory(mRootEglBase.getEglBaseContext(), true /* enableIntelVp8Encoder */, true),
320 | new DefaultVideoDecoderFactory(mRootEglBase.getEglBaseContext()));
321 |
322 | String signaling = context.getString(R.string.signaling_addr);
323 | try {
324 | mSocket = IO.socket(signaling);
325 | } catch (URISyntaxException e) {
326 | e.printStackTrace();
327 | }
328 | mSocket.on("id", messageHandler.onId);
329 | mSocket.on("message", messageHandler.onMessage);
330 | mSocket.on(Socket.EVENT_CONNECT, new Emitter.Listener() {
331 | @Override
332 | public void call(Object... args) {
333 | Log.d(TAG, "socket state connect");
334 | }
335 | });
336 | mSocket.on(Socket.EVENT_DISCONNECT, new Emitter.Listener() {
337 | @Override
338 | public void call(Object... args) {
339 | Log.d(TAG, "socket state disconnect");
340 | }
341 | });
342 | mSocket.on(Socket.EVENT_ERROR, new Emitter.Listener() {
343 | @Override
344 | public void call(Object... args) {
345 | Log.d(TAG, "socket state error");
346 | }
347 | });
348 | mSocket.connect();
349 |
350 | iceServers.add(new PeerConnection.IceServer(context.getString(R.string.stun_addr)));
351 |
352 | // mPeerConnConstraints.mandatory.add(new MediaConstraints.KeyValuePair("OfferToReceiveAudio", "true"));
353 | mPeerConnConstraints.mandatory.add(new MediaConstraints.KeyValuePair("OfferToReceiveVideo", "true"));
354 | mPeerConnConstraints.optional.add(new MediaConstraints.KeyValuePair("DtlsSrtpKeyAgreement", "true"));
355 | }
356 |
357 | /**
358 | * Call this method in Activity.onDestroy()
359 | */
360 | public void destroy() {
361 | for (Peer peer : peers.values()) {
362 | peer.pc.dispose();
363 | }
364 | if (factory != null) {
365 | factory.dispose();
366 | }
367 | if (mVideoSource != null) {
368 | mVideoSource.dispose();
369 | }
370 | mSocket.disconnect();
371 | mSocket.close();
372 | }
373 |
374 | private int findEndPoint() {
375 | for (int i = 0; i < MAX_PEER; i++) if (!endPoints[i]) return i;
376 | return MAX_PEER;
377 | }
378 |
379 | /**
380 | * Start the mSocket.
381 | *
382 | * Set up the local stream and notify the signaling server.
383 | * Call this method after onCallReady.
384 | *
385 | * @param name mSocket name
386 | */
387 | public void start(String name) {
388 | initScreenCapturStream();
389 | try {
390 | JSONObject message = new JSONObject();
391 | message.put("name", name);
392 | mSocket.emit("readyToStream", message);
393 | } catch (JSONException e) {
394 | e.printStackTrace();
395 | }
396 | }
397 |
398 | private void initScreenCapturStream() {
399 | mLocalMediaStream = factory.createLocalMediaStream("ARDAMS");
400 | MediaConstraints videoConstraints = new MediaConstraints();
401 | videoConstraints.mandatory.add(new MediaConstraints.KeyValuePair("maxHeight", Integer.toString(mPeerConnParams.videoHeight)));
402 | videoConstraints.mandatory.add(new MediaConstraints.KeyValuePair("maxWidth", Integer.toString(mPeerConnParams.videoWidth)));
403 | videoConstraints.mandatory.add(new MediaConstraints.KeyValuePair("maxFrameRate", Integer.toString(mPeerConnParams.videoFps)));
404 | videoConstraints.mandatory.add(new MediaConstraints.KeyValuePair("minFrameRate", Integer.toString(mPeerConnParams.videoFps)));
405 |
406 | mVideoSource = factory.createVideoSource(videoCapturer);
407 | videoCapturer.startCapture(mPeerConnParams.videoWidth, mPeerConnParams.videoHeight, mPeerConnParams.videoFps);
408 | VideoTrack localVideoTrack = factory.createVideoTrack(VIDEO_TRACK_ID, mVideoSource);
409 | localVideoTrack.setEnabled(true);
410 | mLocalMediaStream.addTrack(factory.createVideoTrack("ARDAMSv0", mVideoSource));
411 |
412 | mListener.onStatusChanged("STREAMING");
413 | }
414 |
415 | }
416 |
--------------------------------------------------------------------------------
/app/src/main/res/drawable-v24/ic_launcher_foreground.xml:
--------------------------------------------------------------------------------
1 |
7 |
12 |
13 |
19 |