Skip to content

Commit 9b1156a

Browse files
itsmeadiitsmeadi
committed
revert unused change
1 parent f819b33 commit 9b1156a

1 file changed

Lines changed: 343 additions & 0 deletions

File tree

‎src/main/java/io/getstream/services/BaseCall.java‎

Lines changed: 343 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,10 @@
1212
*/
1313
package io.getstream.services;
1414

15+
import io.getstream.exceptions.StreamException;
1516
import io.getstream.models.*;
17+
import io.getstream.models.framework.StreamResponse;
18+
import org.jetbrains.annotations.NotNull;
1619

1720
class BaseCall {
1821
protected Video service;
@@ -24,4 +27,344 @@ public BaseCall(String callType, String callID, Video service) {
2427
this.callID = callID;
2528
this.service = service;
2629
}
30+
31+
@NotNull
32+
public StreamResponse<GetCallResponse> get(GetCallRequest request) throws StreamException {
33+
return service.getCall(this.callType, this.callID, request).execute();
34+
}
35+
36+
public StreamResponse<GetCallResponse> get() throws StreamException {
37+
return this.get(new GetCallRequest());
38+
}
39+
40+
@NotNull
41+
public StreamResponse<UpdateCallResponse> update(UpdateCallRequest request)
42+
throws StreamException {
43+
return service.updateCall(this.callType, this.callID, request).execute();
44+
}
45+
46+
public StreamResponse<UpdateCallResponse> update() throws StreamException {
47+
return this.update(new UpdateCallRequest());
48+
}
49+
50+
@NotNull
51+
public StreamResponse<GetOrCreateCallResponse> getOrCreate(GetOrCreateCallRequest request)
52+
throws StreamException {
53+
return service.getOrCreateCall(this.callType, this.callID, request).execute();
54+
}
55+
56+
public StreamResponse<GetOrCreateCallResponse> getOrCreate() throws StreamException {
57+
return this.getOrCreate(new GetOrCreateCallRequest());
58+
}
59+
60+
@NotNull
61+
public StreamResponse<BlockUserResponse> blockUser(BlockUserRequest request)
62+
throws StreamException {
63+
return service.blockUser(this.callType, this.callID, request).execute();
64+
}
65+
66+
@NotNull
67+
public StreamResponse<SendClosedCaptionResponse> sendClosedCaption(
68+
SendClosedCaptionRequest request) throws StreamException {
69+
return service.sendClosedCaption(this.callType, this.callID, request).execute();
70+
}
71+
72+
@NotNull
73+
public StreamResponse<DeleteCallResponse> delete(DeleteCallRequest request)
74+
throws StreamException {
75+
return service.deleteCall(this.callType, this.callID, request).execute();
76+
}
77+
78+
public StreamResponse<DeleteCallResponse> delete() throws StreamException {
79+
return this.delete(new DeleteCallRequest());
80+
}
81+
82+
@NotNull
83+
public StreamResponse<SendCallEventResponse> sendCallEvent(SendCallEventRequest request)
84+
throws StreamException {
85+
return service.sendCallEvent(this.callType, this.callID, request).execute();
86+
}
87+
88+
public StreamResponse<SendCallEventResponse> sendCallEvent() throws StreamException {
89+
return this.sendCallEvent(new SendCallEventRequest());
90+
}
91+
92+
@NotNull
93+
public StreamResponse<CollectUserFeedbackResponse> collectUserFeedback(
94+
CollectUserFeedbackRequest request) throws StreamException {
95+
return service.collectUserFeedback(this.callType, this.callID, request).execute();
96+
}
97+
98+
@NotNull
99+
public StreamResponse<GoLiveResponse> goLive(GoLiveRequest request) throws StreamException {
100+
return service.goLive(this.callType, this.callID, request).execute();
101+
}
102+
103+
public StreamResponse<GoLiveResponse> goLive() throws StreamException {
104+
return this.goLive(new GoLiveRequest());
105+
}
106+
107+
@NotNull
108+
public StreamResponse<KickUserResponse> kickUser(KickUserRequest request) throws StreamException {
109+
return service.kickUser(this.callType, this.callID, request).execute();
110+
}
111+
112+
@NotNull
113+
public StreamResponse<EndCallResponse> end(EndCallRequest request) throws StreamException {
114+
return service.endCall(this.callType, this.callID, request).execute();
115+
}
116+
117+
public StreamResponse<EndCallResponse> end() throws StreamException {
118+
return this.end(new EndCallRequest());
119+
}
120+
121+
@NotNull
122+
public StreamResponse<UpdateCallMembersResponse> updateCallMembers(
123+
UpdateCallMembersRequest request) throws StreamException {
124+
return service.updateCallMembers(this.callType, this.callID, request).execute();
125+
}
126+
127+
public StreamResponse<UpdateCallMembersResponse> updateCallMembers() throws StreamException {
128+
return this.updateCallMembers(new UpdateCallMembersRequest());
129+
}
130+
131+
@NotNull
132+
public StreamResponse<MuteUsersResponse> muteUsers(MuteUsersRequest request)
133+
throws StreamException {
134+
return service.muteUsers(this.callType, this.callID, request).execute();
135+
}
136+
137+
public StreamResponse<MuteUsersResponse> muteUsers() throws StreamException {
138+
return this.muteUsers(new MuteUsersRequest());
139+
}
140+
141+
@NotNull
142+
public StreamResponse<QueryCallParticipantsResponse> queryCallParticipants(
143+
QueryCallParticipantsRequest request) throws StreamException {
144+
return service.queryCallParticipants(this.callType, this.callID, request).execute();
145+
}
146+
147+
public StreamResponse<QueryCallParticipantsResponse> queryCallParticipants()
148+
throws StreamException {
149+
return this.queryCallParticipants(new QueryCallParticipantsRequest());
150+
}
151+
152+
@NotNull
153+
public StreamResponse<PinResponse> videoPin(VideoPinRequest request) throws StreamException {
154+
return service.videoPin(this.callType, this.callID, request).execute();
155+
}
156+
157+
@NotNull
158+
public StreamResponse<ListRecordingsResponse> listRecordings(ListRecordingsRequest request)
159+
throws StreamException {
160+
return service.listRecordings(this.callType, this.callID, request).execute();
161+
}
162+
163+
public StreamResponse<ListRecordingsResponse> listRecordings() throws StreamException {
164+
return this.listRecordings(new ListRecordingsRequest());
165+
}
166+
167+
@NotNull
168+
public StreamResponse<GetCallReportResponse> getCallReport(GetCallReportRequest request)
169+
throws StreamException {
170+
return service.getCallReport(this.callType, this.callID, request).execute();
171+
}
172+
173+
public StreamResponse<GetCallReportResponse> getCallReport() throws StreamException {
174+
return this.getCallReport(new GetCallReportRequest());
175+
}
176+
177+
@NotNull
178+
public StreamResponse<StartRTMPBroadcastsResponse> startRTMPBroadcasts(
179+
StartRTMPBroadcastsRequest request) throws StreamException {
180+
return service.startRTMPBroadcasts(this.callType, this.callID, request).execute();
181+
}
182+
183+
@NotNull
184+
public StreamResponse<StopAllRTMPBroadcastsResponse> stopAllRTMPBroadcasts(
185+
StopAllRTMPBroadcastsRequest request) throws StreamException {
186+
return service.stopAllRTMPBroadcasts(this.callType, this.callID, request).execute();
187+
}
188+
189+
public StreamResponse<StopAllRTMPBroadcastsResponse> stopAllRTMPBroadcasts()
190+
throws StreamException {
191+
return this.stopAllRTMPBroadcasts(new StopAllRTMPBroadcastsRequest());
192+
}
193+
194+
@NotNull
195+
public StreamResponse<StopRTMPBroadcastsResponse> stopRTMPBroadcast(
196+
@NotNull String name, StopRTMPBroadcastRequest request) throws StreamException {
197+
return service.stopRTMPBroadcast(this.callType, this.callID, name, request).execute();
198+
}
199+
200+
public StreamResponse<StopRTMPBroadcastsResponse> stopRTMPBroadcast(@NotNull String name)
201+
throws StreamException {
202+
return this.stopRTMPBroadcast(name, new StopRTMPBroadcastRequest());
203+
}
204+
205+
@NotNull
206+
public StreamResponse<StartHLSBroadcastingResponse> startHLSBroadcasting(
207+
StartHLSBroadcastingRequest request) throws StreamException {
208+
return service.startHLSBroadcasting(this.callType, this.callID, request).execute();
209+
}
210+
211+
public StreamResponse<StartHLSBroadcastingResponse> startHLSBroadcasting()
212+
throws StreamException {
213+
return this.startHLSBroadcasting(new StartHLSBroadcastingRequest());
214+
}
215+
216+
@NotNull
217+
public StreamResponse<StartClosedCaptionsResponse> startClosedCaptions(
218+
StartClosedCaptionsRequest request) throws StreamException {
219+
return service.startClosedCaptions(this.callType, this.callID, request).execute();
220+
}
221+
222+
public StreamResponse<StartClosedCaptionsResponse> startClosedCaptions() throws StreamException {
223+
return this.startClosedCaptions(new StartClosedCaptionsRequest());
224+
}
225+
226+
@NotNull
227+
public StreamResponse<StartFrameRecordingResponse> startFrameRecording(
228+
StartFrameRecordingRequest request) throws StreamException {
229+
return service.startFrameRecording(this.callType, this.callID, request).execute();
230+
}
231+
232+
public StreamResponse<StartFrameRecordingResponse> startFrameRecording() throws StreamException {
233+
return this.startFrameRecording(new StartFrameRecordingRequest());
234+
}
235+
236+
@NotNull
237+
public StreamResponse<StartRecordingResponse> startRecording(StartRecordingRequest request)
238+
throws StreamException {
239+
return service.startRecording(this.callType, this.callID, request).execute();
240+
}
241+
242+
public StreamResponse<StartRecordingResponse> startRecording() throws StreamException {
243+
return this.startRecording(new StartRecordingRequest());
244+
}
245+
246+
@NotNull
247+
public StreamResponse<StartTranscriptionResponse> startTranscription(
248+
StartTranscriptionRequest request) throws StreamException {
249+
return service.startTranscription(this.callType, this.callID, request).execute();
250+
}
251+
252+
public StreamResponse<StartTranscriptionResponse> startTranscription() throws StreamException {
253+
return this.startTranscription(new StartTranscriptionRequest());
254+
}
255+
256+
@NotNull
257+
public StreamResponse<StopHLSBroadcastingResponse> stopHLSBroadcasting(
258+
StopHLSBroadcastingRequest request) throws StreamException {
259+
return service.stopHLSBroadcasting(this.callType, this.callID, request).execute();
260+
}
261+
262+
public StreamResponse<StopHLSBroadcastingResponse> stopHLSBroadcasting() throws StreamException {
263+
return this.stopHLSBroadcasting(new StopHLSBroadcastingRequest());
264+
}
265+
266+
@NotNull
267+
public StreamResponse<StopClosedCaptionsResponse> stopClosedCaptions(
268+
StopClosedCaptionsRequest request) throws StreamException {
269+
return service.stopClosedCaptions(this.callType, this.callID, request).execute();
270+
}
271+
272+
public StreamResponse<StopClosedCaptionsResponse> stopClosedCaptions() throws StreamException {
273+
return this.stopClosedCaptions(new StopClosedCaptionsRequest());
274+
}
275+
276+
@NotNull
277+
public StreamResponse<StopFrameRecordingResponse> stopFrameRecording(
278+
StopFrameRecordingRequest request) throws StreamException {
279+
return service.stopFrameRecording(this.callType, this.callID, request).execute();
280+
}
281+
282+
public StreamResponse<StopFrameRecordingResponse> stopFrameRecording() throws StreamException {
283+
return this.stopFrameRecording(new StopFrameRecordingRequest());
284+
}
285+
286+
@NotNull
287+
public StreamResponse<StopLiveResponse> stopLive(StopLiveRequest request) throws StreamException {
288+
return service.stopLive(this.callType, this.callID, request).execute();
289+
}
290+
291+
public StreamResponse<StopLiveResponse> stopLive() throws StreamException {
292+
return this.stopLive(new StopLiveRequest());
293+
}
294+
295+
@NotNull
296+
public StreamResponse<StopRecordingResponse> stopRecording(StopRecordingRequest request)
297+
throws StreamException {
298+
return service.stopRecording(this.callType, this.callID, request).execute();
299+
}
300+
301+
public StreamResponse<StopRecordingResponse> stopRecording() throws StreamException {
302+
return this.stopRecording(new StopRecordingRequest());
303+
}
304+
305+
@NotNull
306+
public StreamResponse<StopTranscriptionResponse> stopTranscription(
307+
StopTranscriptionRequest request) throws StreamException {
308+
return service.stopTranscription(this.callType, this.callID, request).execute();
309+
}
310+
311+
public StreamResponse<StopTranscriptionResponse> stopTranscription() throws StreamException {
312+
return this.stopTranscription(new StopTranscriptionRequest());
313+
}
314+
315+
@NotNull
316+
public StreamResponse<ListTranscriptionsResponse> listTranscriptions(
317+
ListTranscriptionsRequest request) throws StreamException {
318+
return service.listTranscriptions(this.callType, this.callID, request).execute();
319+
}
320+
321+
public StreamResponse<ListTranscriptionsResponse> listTranscriptions() throws StreamException {
322+
return this.listTranscriptions(new ListTranscriptionsRequest());
323+
}
324+
325+
@NotNull
326+
public StreamResponse<UnblockUserResponse> unblockUser(UnblockUserRequest request)
327+
throws StreamException {
328+
return service.unblockUser(this.callType, this.callID, request).execute();
329+
}
330+
331+
@NotNull
332+
public StreamResponse<UnpinResponse> videoUnpin(VideoUnpinRequest request)
333+
throws StreamException {
334+
return service.videoUnpin(this.callType, this.callID, request).execute();
335+
}
336+
337+
@NotNull
338+
public StreamResponse<UpdateUserPermissionsResponse> updateUserPermissions(
339+
UpdateUserPermissionsRequest request) throws StreamException {
340+
return service.updateUserPermissions(this.callType, this.callID, request).execute();
341+
}
342+
343+
@NotNull
344+
public StreamResponse<DeleteRecordingResponse> deleteRecording(
345+
@NotNull String session, @NotNull String filename, DeleteRecordingRequest request)
346+
throws StreamException {
347+
return service
348+
.deleteRecording(this.callType, this.callID, session, filename, request)
349+
.execute();
350+
}
351+
352+
public StreamResponse<DeleteRecordingResponse> deleteRecording(
353+
@NotNull String session, @NotNull String filename) throws StreamException {
354+
return this.deleteRecording(session, filename, new DeleteRecordingRequest());
355+
}
356+
357+
@NotNull
358+
public StreamResponse<DeleteTranscriptionResponse> deleteTranscription(
359+
@NotNull String session, @NotNull String filename, DeleteTranscriptionRequest request)
360+
throws StreamException {
361+
return service
362+
.deleteTranscription(this.callType, this.callID, session, filename, request)
363+
.execute();
364+
}
365+
366+
public StreamResponse<DeleteTranscriptionResponse> deleteTranscription(
367+
@NotNull String session, @NotNull String filename) throws StreamException {
368+
return this.deleteTranscription(session, filename, new DeleteTranscriptionRequest());
369+
}
27370
}

0 commit comments

Comments
 (0)