正在查看： Plus 12 v10.13.1.1 应用的 VoIPService.java JAVA 源代码文件
本页面展示 JAVA 反编译生成的源代码文件，支持语法高亮显示。 仅供安全研究与技术分析使用，严禁用于任何非法用途。请遵守相关法律法规。
页面标题
页面副标题
Plus 12 v10.13.1.1 - VoIPService.java 源代码
package org.telegram.messenger.voip;
import android.annotation.SuppressLint;
import android.annotation.TargetApi;
import android.app.Activity;
import android.app.KeyguardManager;
import android.app.Notification;
import android.app.PendingIntent;
import android.app.Service;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothProfile;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.graphics.Bitmap;
import android.graphics.drawable.Icon;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.media.AudioDeviceCallback;
import android.media.AudioDeviceInfo;
import android.media.AudioManager;
import android.media.AudioTrack;
import android.media.MediaPlayer;
import android.media.MediaRouter;
import android.media.SoundPool;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.PowerManager;
import android.os.SystemClock;
import android.os.Vibrator;
import android.telecom.CallAudioState;
import android.telecom.Connection;
import android.telecom.DisconnectCause;
import android.telecom.PhoneAccount;
import android.telecom.PhoneAccountHandle;
import android.telecom.TelecomManager;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import android.util.LruCache;
import android.view.KeyEvent;
import android.widget.Toast;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Method;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import org.telegram.messenger.AccountInstance;
import org.telegram.messenger.AndroidUtilities;
import org.telegram.messenger.ApplicationLoader;
import org.telegram.messenger.BuildConfig;
import org.telegram.messenger.BuildVars;
import org.telegram.messenger.ChatObject;
import org.telegram.messenger.ContactsController;
import org.telegram.messenger.DispatchQueue;
import org.telegram.messenger.FileLog;
import org.telegram.messenger.LocaleController;
import org.telegram.messenger.MediaController;
import org.telegram.messenger.MessageObject;
import org.telegram.messenger.MessagesController;
import org.telegram.messenger.MessagesStorage;
import org.telegram.messenger.NotificationCenter;
import org.telegram.messenger.NotificationsController;
import org.telegram.messenger.R;
import org.telegram.messenger.SharedConfig;
import org.telegram.messenger.StatsController;
import org.telegram.messenger.UserConfig;
import org.telegram.messenger.UserObject;
import org.telegram.messenger.Utilities;
import org.telegram.messenger.XiaomiUtilities;
import org.telegram.messenger.voip.Instance;
import org.telegram.messenger.voip.NativeInstance;
import org.telegram.messenger.voip.VoIPController;
import org.telegram.messenger.voip.VoIPService;
import org.telegram.tgnet.ConnectionsManager;
import org.telegram.tgnet.NativeByteBuffer;
import org.telegram.tgnet.RequestDelegate;
import org.telegram.tgnet.RequestDelegateTimestamp;
import org.telegram.tgnet.TLObject;
import org.telegram.tgnet.TLRPC;
import org.telegram.ui.ActionBar.BottomSheet;
import org.telegram.ui.ActionBar.PlusSettings;
import org.telegram.ui.ActionBar.Theme;
import org.telegram.ui.Components.JoinCallAlert;
import org.telegram.ui.Components.voip.VoIPHelper;
import org.telegram.ui.LaunchActivity;
import org.telegram.ui.VoIPFeedbackActivity;
import org.telegram.ui.VoIPFragment;
import org.telegram.ui.VoIPPermissionActivity;
import org.webrtc.VideoFrame;
import org.webrtc.VideoSink;
import org.webrtc.voiceengine.WebRtcAudioTrack;
@SuppressLint({"NewApi"})
public class VoIPService extends Service implements SensorEventListener, AudioManager.OnAudioFocusChangeListener, VoIPController.ConnectionStateListener, NotificationCenter.NotificationCenterDelegate {
public static final String ACTION_HEADSET_PLUG = "android.intent.action.HEADSET_PLUG";
public static final int AUDIO_ROUTE_BLUETOOTH = 2;
public static final int AUDIO_ROUTE_EARPIECE = 0;
public static final int AUDIO_ROUTE_SPEAKER = 1;
public static final int CALL_MIN_LAYER = 65;
public static final int CAPTURE_DEVICE_CAMERA = 0;
public static final int CAPTURE_DEVICE_SCREEN = 1;
public static final int DISCARD_REASON_DISCONNECT = 2;
public static final int DISCARD_REASON_HANGUP = 1;
public static final int DISCARD_REASON_LINE_BUSY = 4;
public static final int DISCARD_REASON_MISSED = 3;
private static final int ID_INCOMING_CALL_NOTIFICATION = 202;
private static final int ID_ONGOING_CALL_NOTIFICATION = 201;
private static final int PROXIMITY_SCREEN_OFF_WAKE_LOCK = 32;
public static final int QUALITY_FULL = 2;
public static final int QUALITY_MEDIUM = 1;
public static final int QUALITY_SMALL = 0;
public static final int STATE_BUSY = 17;
public static final int STATE_CREATING = 6;
public static final int STATE_ENDED = 11;
public static final int STATE_ESTABLISHED = 3;
public static final int STATE_EXCHANGING_KEYS = 12;
public static final int STATE_FAILED = 4;
public static final int STATE_HANGING_UP = 10;
public static final int STATE_RECONNECTING = 5;
public static final int STATE_REQUESTING = 14;
public static final int STATE_RINGING = 16;
public static final int STATE_WAITING = 13;
public static final int STATE_WAITING_INCOMING = 15;
public static final int STATE_WAIT_INIT = 1;
public static final int STATE_WAIT_INIT_ACK = 2;
public static NativeInstance.AudioLevelsCallback audioLevelsCallback;
public static TLRPC.PhoneCall callIShouldHavePutIntoIntent;
private static Runnable setModeRunnable;
private static VoIPService sharedInstance;
private byte[] a_or_b;
private boolean audioConfigured;
private AudioDeviceCallback audioDeviceCallback;
private byte[] authKey;
private boolean bluetoothScoActive;
private boolean bluetoothScoConnecting;
private BluetoothAdapter btAdapter;
private int callDiscardReason;
private int callReqId;
private long callStartTime;
private TLRPC.Chat chat;
private int checkRequestId;
private int classGuid;
private Runnable connectingSoundRunnable;
private PowerManager.WakeLock cpuWakelock;
private boolean createGroupCall;
public String currentBluetoothDeviceName;
public boolean currentGroupModeStreaming;
private Runnable delayedStartOutgoingCall;
private boolean didDeleteConnectionServiceContact;
private boolean endCallAfterRequest;
public boolean fetchingBluetoothDeviceName;
private boolean forceRating;
private byte[] g_a;
private byte[] g_a_hash;
public ChatObject.Call groupCall;
private volatile CountDownLatch groupCallBottomSheetLatch;
private TLRPC.InputPeer groupCallPeer;
private boolean hasAudioFocus;
public boolean hasFewPeers;
private boolean isBtHeadsetConnected;
private volatile boolean isCallEnded;
private boolean isHeadsetPlugged;
private boolean isOutgoing;
private boolean isPrivateScreencast;
private boolean isProximityNear;
private boolean isVideoAvailable;
private String joinHash;
private long keyFingerprint;
private String lastError;
private NetworkInfo lastNetInfo;
private SensorEvent lastSensorEvent;
private long lastTypingTimeSend;
private Boolean mHasEarpiece;
private boolean micMute;
public boolean micSwitching;
private TLRPC.TL_dataJSON myParams;
private boolean needPlayEndSound;
private boolean needRateCall;
private boolean needSendDebugLog;
private boolean needSwitchToBluetoothAfterScoActivates;
private boolean notificationsDisabled;
private Runnable onDestroyRunnable;
private boolean playedConnectedSound;
private boolean playingSound;
private Instance.TrafficStats prevTrafficStats;
public TLRPC.PhoneCall privateCall;
private PowerManager.WakeLock proximityWakelock;
private boolean reconnectScreenCapture;
private MediaPlayer ringtonePlayer;
private int scheduleDate;
private Runnable shortPollRunnable;
private int signalBarCount;
private SoundPool soundPool;
private int spAllowTalkId;
private int spBusyId;
private int spConnectingId;
private int spEndId;
private int spFailedID;
private int spPlayId;
private int spRingbackID;
private int spStartRecordId;
private int spVoiceChatConnecting;
private int spVoiceChatEndId;
private int spVoiceChatStartId;
private boolean speakerphoneStateToSet;
private boolean startedRinging;
private boolean switchingAccount;
private boolean switchingCamera;
private boolean switchingStream;
private Runnable switchingStreamTimeoutRunnable;
private CallConnection systemCallConnection;
private Runnable timeoutRunnable;
private boolean unmutedByHold;
private Runnable updateNotificationRunnable;
private TLRPC.User user;
private Vibrator vibrator;
public boolean videoCall;
private boolean wasConnected;
private boolean wasEstablished;
private static final boolean USE_CONNECTION_SERVICE = isDeviceCompatibleWithConnectionServiceAPI();
private static final Object sync = new Object();
private int currentAccount = -1;
private int currentState = 0;
private boolean isFrontFaceCamera = true;
private int previousAudioOutput = -1;
private ArrayList<StateListener> stateListeners = new ArrayList<>();
private int remoteVideoState = 0;
private int[] mySource = new int[2];
private NativeInstance[] tgVoip = new NativeInstance[2];
private long[] captureDevice = new long[2];
private boolean[] destroyCaptureDevice = {true, true};
private int[] videoState = {0, 0};
private int remoteAudioState = 1;
private int audioRouteToSet = 2;
public final SharedUIParams sharedUIParams = new SharedUIParams();
private ArrayList<TLRPC.PhoneCall> pendingUpdates = new ArrayList<>();
private HashMap<String, Integer> currentStreamRequestTimestamp = new HashMap<>();
private Runnable afterSoundRunnable = new AnonymousClass1();
private BluetoothProfile.ServiceListener serviceListener = new BluetoothProfile.ServiceListener() {
@Override
public void onServiceDisconnected(int profile) {
}
@Override
public void onServiceConnected(int profile, BluetoothProfile proxy) {
try {
if (Build.VERSION.SDK_INT < 31) {
Iterator<BluetoothDevice> it = proxy.getConnectedDevices().iterator();
while (true) {
if (!it.hasNext()) {
break;
}
BluetoothDevice next = it.next();
if (proxy.getConnectionState(next) == 2) {
VoIPService.this.currentBluetoothDeviceName = next.getName();
break;
}
}
}
BluetoothAdapter.getDefaultAdapter().closeProfileProxy(profile, proxy);
VoIPService.this.fetchingBluetoothDeviceName = false;
} catch (Throwable th) {
FileLog.e(th);
}
}
};
private BroadcastReceiver receiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (VoIPService.ACTION_HEADSET_PLUG.equals(intent.getAction())) {
VoIPService.this.isHeadsetPlugged = intent.getIntExtra("state", 0) == 1;
if (VoIPService.this.isHeadsetPlugged && VoIPService.this.proximityWakelock != null && VoIPService.this.proximityWakelock.isHeld()) {
VoIPService.this.proximityWakelock.release();
}
if (VoIPService.this.isHeadsetPlugged) {
AudioManager audioManager = (AudioManager) VoIPService.this.getSystemService("audio");
if (VoipAudioManager.get().isSpeakerphoneOn()) {
VoIPService.this.previousAudioOutput = 0;
} else if (audioManager.isBluetoothScoOn()) {
VoIPService.this.previousAudioOutput = 2;
} else {
VoIPService.this.previousAudioOutput = 1;
}
VoIPService.this.setAudioOutput(1);
} else if (VoIPService.this.previousAudioOutput >= 0) {
VoIPService voIPService = VoIPService.this;
voIPService.setAudioOutput(voIPService.previousAudioOutput);
VoIPService.this.previousAudioOutput = -1;
}
VoIPService.this.isProximityNear = false;
VoIPService.this.updateOutputGainControlState();
return;
}
if ("android.net.conn.CONNECTIVITY_CHANGE".equals(intent.getAction())) {
VoIPService.this.updateNetworkType();
return;
}
if ("android.bluetooth.headset.profile.action.CONNECTION_STATE_CHANGED".equals(intent.getAction())) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("bt headset state = " + intent.getIntExtra("android.bluetooth.profile.extra.STATE", 0));
}
VoIPService.this.updateBluetoothHeadsetState(intent.getIntExtra("android.bluetooth.profile.extra.STATE", 0) == 2);
return;
}
if ("android.media.ACTION_SCO_AUDIO_STATE_UPDATED".equals(intent.getAction())) {
int intExtra = intent.getIntExtra("android.media.extra.SCO_AUDIO_STATE", 0);
if (BuildVars.LOGS_ENABLED) {
FileLog.e("Bluetooth SCO state updated: " + intExtra);
}
if (intExtra == 0 && VoIPService.this.isBtHeadsetConnected && (!VoIPService.this.btAdapter.isEnabled() || VoIPService.this.btAdapter.getProfileConnectionState(1) != 2)) {
VoIPService.this.updateBluetoothHeadsetState(false);
return;
}
VoIPService.this.bluetoothScoConnecting = intExtra == 2;
VoIPService.this.bluetoothScoActive = intExtra == 1;
if (VoIPService.this.bluetoothScoActive) {
VoIPService.this.fetchBluetoothDeviceName();
if (VoIPService.this.needSwitchToBluetoothAfterScoActivates) {
VoIPService.this.needSwitchToBluetoothAfterScoActivates = false;
AudioManager audioManager2 = (AudioManager) VoIPService.this.getSystemService("audio");
VoipAudioManager.get().setSpeakerphoneOn(false);
audioManager2.setBluetoothScoOn(true);
}
}
Iterator it = VoIPService.this.stateListeners.iterator();
while (it.hasNext()) {
((StateListener) it.next()).onAudioSettingsChanged();
}
return;
}
if ("android.intent.action.PHONE_STATE".equals(intent.getAction())) {
if (TelephonyManager.EXTRA_STATE_OFFHOOK.equals(intent.getStringExtra("state"))) {
VoIPService.this.hangUp();
}
} else if ("android.intent.action.SCREEN_ON".equals(intent.getAction())) {
for (int i = 0; i < VoIPService.this.stateListeners.size(); i++) {
((StateListener) VoIPService.this.stateListeners.get(i)).onScreenOnChange(true);
}
} else if ("android.intent.action.SCREEN_OFF".equals(intent.getAction())) {
for (int i2 = 0; i2 < VoIPService.this.stateListeners.size(); i2++) {
((StateListener) VoIPService.this.stateListeners.get(i2)).onScreenOnChange(false);
}
}
}
};
private final HashMap<String, TLRPC.TL_groupCallParticipant> waitingFrameParticipant = new HashMap<>();
private final LruCache<String, ProxyVideoSink> proxyVideoSinkLruCache = new LruCache<String, ProxyVideoSink>(6) {
@Override
public void entryRemoved(boolean evicted, String key, ProxyVideoSink oldValue, ProxyVideoSink newValue) {
super.entryRemoved(evicted, (boolean) key, oldValue, newValue);
VoIPService.this.tgVoip[0].removeIncomingVideoOutput(oldValue.nativeInstance);
}
};
private ProxyVideoSink[] localSink = new ProxyVideoSink[2];
private ProxyVideoSink[] remoteSink = new ProxyVideoSink[2];
private ProxyVideoSink[] currentBackgroundSink = new ProxyVideoSink[2];
private String[] currentBackgroundEndpointId = new String[2];
private HashMap<String, ProxyVideoSink> remoteSinks = new HashMap<>();
public static class SharedUIParams {
public boolean cameraAlertWasShowed;
public boolean tapToVideoTooltipWasShowed;
public boolean wasVideoCall;
}
public interface StateListener {
public final class CC {
public static void $default$onAudioSettingsChanged(StateListener stateListener) {
}
public static void $default$onCameraFirstFrameAvailable(StateListener stateListener) {
}
public static void $default$onCameraSwitch(StateListener stateListener, boolean z) {
}
public static void $default$onMediaStateUpdated(StateListener stateListener, int i, int i2) {
}
public static void $default$onScreenOnChange(StateListener stateListener, boolean z) {
}
public static void $default$onSignalBarsCountChanged(StateListener stateListener, int i) {
}
public static void $default$onStateChanged(StateListener stateListener, int i) {
}
public static void $default$onVideoAvailableChange(StateListener stateListener, boolean z) {
}
}
void onAudioSettingsChanged();
void onCameraFirstFrameAvailable();
void onCameraSwitch(boolean isFrontFace);
void onMediaStateUpdated(int audioState, int videoState);
void onScreenOnChange(boolean screenOn);
void onSignalBarsCountChanged(int count);
void onStateChanged(int state);
void onVideoAvailableChange(boolean isAvailable);
}
private static boolean isDeviceCompatibleWithConnectionServiceAPI() {
return false;
}
public static void lambda$createGroupInstance$37(TLObject tLObject, TLRPC.TL_error tL_error) {
}
public static void lambda$onSignalingData$60(TLObject tLObject, TLRPC.TL_error tL_error) {
}
private void onTgVoipPreStop() {
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
@Override
public IBinder onBind(Intent intent) {
return null;
}
public class AnonymousClass1 implements Runnable {
public AnonymousClass1() {
}
@Override
public void run() {
final AudioManager audioManager = (AudioManager) VoIPService.this.getSystemService("audio");
VoipAudioManager voipAudioManager = VoipAudioManager.get();
audioManager.abandonAudioFocus(VoIPService.this);
audioManager.unregisterMediaButtonEventReceiver(new ComponentName(VoIPService.this, (Class<?>) VoIPMediaButtonReceiver.class));
if (VoIPService.this.audioDeviceCallback != null) {
audioManager.unregisterAudioDeviceCallback(VoIPService.this.audioDeviceCallback);
}
if (!VoIPService.USE_CONNECTION_SERVICE && VoIPService.sharedInstance == null) {
if (VoIPService.this.isBtHeadsetConnected) {
audioManager.stopBluetoothSco();
audioManager.setBluetoothScoOn(false);
VoIPService.this.bluetoothScoActive = false;
VoIPService.this.bluetoothScoConnecting = false;
}
voipAudioManager.setSpeakerphoneOn(false);
}
Utilities.globalQueue.postRunnable(new Runnable() {
@Override
public final void run() {
VoIPService.AnonymousClass1.this.lambda$run$0();
}
});
DispatchQueue dispatchQueue = Utilities.globalQueue;
Runnable runnable = new Runnable() {
@Override
public final void run() {
VoIPService.AnonymousClass1.lambda$run$1(audioManager);
}
};
VoIPService.setModeRunnable = runnable;
dispatchQueue.postRunnable(runnable);
}
public void lambda$run$0() {
VoIPService.this.soundPool.release();
}
public static void lambda$run$1(AudioManager audioManager) {
synchronized (VoIPService.sync) {
if (VoIPService.setModeRunnable == null) {
return;
}
VoIPService.setModeRunnable = null;
try {
audioManager.setMode(0);
} catch (SecurityException e) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("Error setting audio more to normal", e);
}
}
}
}
}
public CountDownLatch getGroupCallBottomSheetLatch() {
return this.groupCallBottomSheetLatch;
}
public boolean isFrontFaceCamera() {
return this.isFrontFaceCamera;
}
public boolean isScreencast() {
return this.isPrivateScreencast;
}
public void setMicMute(boolean mute, boolean hold, boolean send) {
TLRPC.TL_groupCallParticipant tL_groupCallParticipant;
if (this.micMute == mute || this.micSwitching) {
return;
}
this.micMute = mute;
ChatObject.Call call = this.groupCall;
if (call != null) {
if (!send && (tL_groupCallParticipant = (TLRPC.TL_groupCallParticipant) call.participants.get(getSelfId())) != null && tL_groupCallParticipant.muted && !tL_groupCallParticipant.can_self_unmute) {
send = true;
}
if (send) {
editCallMember(UserConfig.getInstance(this.currentAccount).getCurrentUser(), Boolean.valueOf(mute), null, null, null, null);
DispatchQueue dispatchQueue = Utilities.globalQueue;
Runnable runnable = new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$setMicMute$0();
}
};
this.updateNotificationRunnable = runnable;
dispatchQueue.postRunnable(runnable);
}
}
this.unmutedByHold = !this.micMute && hold;
NativeInstance[] nativeInstanceArr = this.tgVoip;
if (nativeInstanceArr[0] != null) {
nativeInstanceArr[0].setMuteMicrophone(mute);
}
Iterator<StateListener> it = this.stateListeners.iterator();
while (it.hasNext()) {
it.next().onAudioSettingsChanged();
}
}
public void lambda$setMicMute$0() {
if (this.updateNotificationRunnable == null) {
return;
}
this.updateNotificationRunnable = null;
TLRPC.Chat chat = this.chat;
showNotification(chat.title, getRoundAvatarBitmap(chat));
}
public boolean mutedByAdmin() {
ChatObject.Call call = this.groupCall;
if (call == null) {
return false;
}
TLRPC.TL_groupCallParticipant tL_groupCallParticipant = (TLRPC.TL_groupCallParticipant) call.participants.get(getSelfId());
return (tL_groupCallParticipant == null || tL_groupCallParticipant.can_self_unmute || !tL_groupCallParticipant.muted || ChatObject.canManageCalls(this.chat)) ? false : true;
}
public boolean hasVideoCapturer() {
return this.captureDevice[0] != 0;
}
public void checkVideoFrame(TLRPC.TL_groupCallParticipant participant, boolean screencast) {
String str = screencast ? participant.presentationEndpoint : participant.videoEndpoint;
if (str == null) {
return;
}
if (!screencast || participant.hasPresentationFrame == 0) {
if (screencast || participant.hasCameraFrame == 0) {
if (this.proxyVideoSinkLruCache.get(str) != null || (this.remoteSinks.get(str) != null && this.waitingFrameParticipant.get(str) == null)) {
if (screencast) {
participant.hasPresentationFrame = 2;
return;
} else {
participant.hasCameraFrame = 2;
return;
}
}
if (this.waitingFrameParticipant.containsKey(str)) {
this.waitingFrameParticipant.put(str, participant);
if (screencast) {
participant.hasPresentationFrame = 1;
return;
} else {
participant.hasCameraFrame = 1;
return;
}
}
if (screencast) {
participant.hasPresentationFrame = 1;
} else {
participant.hasCameraFrame = 1;
}
this.waitingFrameParticipant.put(str, participant);
addRemoteSink(participant, screencast, new AnonymousClass5(str, screencast), null);
}
}
}
public class AnonymousClass5 implements VideoSink {
public final String val$endpointId;
public final boolean val$screencast;
public void setParentSink(VideoSink videoSink) {
VideoSink.-CC.$default$setParentSink(this, videoSink);
}
public AnonymousClass5(final String val$endpointId, final boolean val$screencast) {
this.val$endpointId = val$endpointId;
this.val$screencast = val$screencast;
}
public void onFrame(VideoFrame frame) {
if (frame == null || frame.getBuffer().getHeight() == 0 || frame.getBuffer().getWidth() == 0) {
return;
}
final String str = this.val$endpointId;
final boolean z = this.val$screencast;
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.AnonymousClass5.this.lambda$onFrame$0(str, this, z);
}
});
}
public void lambda$onFrame$0(String str, VideoSink videoSink, boolean z) {
TLRPC.TL_groupCallParticipant tL_groupCallParticipant = (TLRPC.TL_groupCallParticipant) VoIPService.this.waitingFrameParticipant.remove(str);
ProxyVideoSink proxyVideoSink = (ProxyVideoSink) VoIPService.this.remoteSinks.get(str);
if (proxyVideoSink != null && proxyVideoSink.target == videoSink) {
VoIPService.this.proxyVideoSinkLruCache.put(str, proxyVideoSink);
VoIPService.this.remoteSinks.remove(str);
proxyVideoSink.setTarget(null);
}
if (tL_groupCallParticipant != null) {
if (z) {
tL_groupCallParticipant.hasPresentationFrame = 2;
} else {
tL_groupCallParticipant.hasCameraFrame = 2;
}
}
ChatObject.Call call = VoIPService.this.groupCall;
if (call != null) {
call.updateVisibleParticipants();
}
}
}
public void clearRemoteSinks() {
this.proxyVideoSinkLruCache.evictAll();
}
public void setAudioRoute(int route) {
if (route == 1) {
setAudioOutput(0);
} else if (route == 0) {
setAudioOutput(1);
} else if (route == 2) {
setAudioOutput(2);
}
}
public static class ProxyVideoSink implements VideoSink {
private VideoSink background;
private long nativeInstance;
private VideoSink target;
public void setParentSink(VideoSink videoSink) {
VideoSink.-CC.$default$setParentSink(this, videoSink);
}
public synchronized void onFrame(VideoFrame frame) {
VideoSink videoSink = this.target;
if (videoSink != null) {
videoSink.onFrame(frame);
}
VideoSink videoSink2 = this.background;
if (videoSink2 != null) {
videoSink2.onFrame(frame);
}
}
public synchronized void setTarget(VideoSink newTarget) {
VideoSink videoSink = this.target;
if (videoSink != newTarget) {
if (videoSink != null) {
videoSink.setParentSink((VideoSink) null);
}
this.target = newTarget;
if (newTarget != null) {
newTarget.setParentSink(this);
}
}
}
public synchronized void setBackground(VideoSink newBackground) {
VideoSink videoSink = this.background;
if (videoSink != null) {
videoSink.setParentSink((VideoSink) null);
}
this.background = newBackground;
if (newBackground != null) {
newBackground.setParentSink(this);
}
}
public synchronized void removeTarget(VideoSink target) {
if (this.target == target) {
this.target = null;
}
}
public synchronized void removeBackground(VideoSink background) {
if (this.background == background) {
this.background = null;
}
}
public synchronized void swap() {
VideoSink videoSink;
if (this.target != null && (videoSink = this.background) != null) {
this.target = videoSink;
this.background = null;
}
}
}
@Override
@SuppressLint({"MissingPermission", "InlinedApi"})
public int onStartCommand(Intent intent, int i, int i2) {
boolean z;
boolean z2;
int i3;
if (sharedInstance != null) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("Tried to start the VoIP service when it's already started");
}
return 2;
}
int intExtra = intent.getIntExtra("account", -1);
this.currentAccount = intExtra;
if (intExtra == -1) {
throw new IllegalStateException("No account specified when starting VoIP service");
}
this.classGuid = ConnectionsManager.generateClassGuid();
long longExtra = intent.getLongExtra("user_id", 0L);
long longExtra2 = intent.getLongExtra("chat_id", 0L);
this.createGroupCall = intent.getBooleanExtra("createGroupCall", false);
this.hasFewPeers = intent.getBooleanExtra("hasFewPeers", false);
this.joinHash = intent.getStringExtra("hash");
long longExtra3 = intent.getLongExtra("peerChannelId", 0L);
long longExtra4 = intent.getLongExtra("peerChatId", 0L);
long longExtra5 = intent.getLongExtra("peerUserId", 0L);
if (longExtra4 != 0) {
TLRPC.TL_inputPeerChat tL_inputPeerChat = new TLRPC.TL_inputPeerChat();
this.groupCallPeer = tL_inputPeerChat;
tL_inputPeerChat.chat_id = longExtra4;
tL_inputPeerChat.access_hash = intent.getLongExtra("peerAccessHash", 0L);
} else if (longExtra3 != 0) {
TLRPC.TL_inputPeerChannel tL_inputPeerChannel = new TLRPC.TL_inputPeerChannel();
this.groupCallPeer = tL_inputPeerChannel;
tL_inputPeerChannel.channel_id = longExtra3;
tL_inputPeerChannel.access_hash = intent.getLongExtra("peerAccessHash", 0L);
} else if (longExtra5 != 0) {
TLRPC.TL_inputPeerUser tL_inputPeerUser = new TLRPC.TL_inputPeerUser();
this.groupCallPeer = tL_inputPeerUser;
tL_inputPeerUser.user_id = longExtra5;
tL_inputPeerUser.access_hash = intent.getLongExtra("peerAccessHash", 0L);
}
this.scheduleDate = intent.getIntExtra("scheduleDate", 0);
this.isOutgoing = intent.getBooleanExtra("is_outgoing", false);
this.videoCall = intent.getBooleanExtra("video_call", false);
this.isVideoAvailable = intent.getBooleanExtra("can_video_call", false);
this.notificationsDisabled = intent.getBooleanExtra("notifications_disabled", false);
if (longExtra != 0) {
this.user = MessagesController.getInstance(this.currentAccount).getUser(Long.valueOf(longExtra));
}
if (longExtra2 != 0) {
TLRPC.Chat chat = MessagesController.getInstance(this.currentAccount).getChat(Long.valueOf(longExtra2));
this.chat = chat;
if (ChatObject.isChannel(chat)) {
MessagesController.getInstance(this.currentAccount).startShortPoll(this.chat, this.classGuid, false);
}
}
loadResources();
int i4 = 0;
while (true) {
ProxyVideoSink[] proxyVideoSinkArr = this.localSink;
if (i4 < proxyVideoSinkArr.length) {
proxyVideoSinkArr[i4] = new ProxyVideoSink();
this.remoteSink[i4] = new ProxyVideoSink();
i4++;
} else {
try {
break;
} catch (Exception e) {
FileLog.e(e);
}
}
}
this.isHeadsetPlugged = ((AudioManager) getSystemService("audio")).isWiredHeadsetOn();
if (this.chat != null && !this.createGroupCall && MessagesController.getInstance(this.currentAccount).getGroupCall(this.chat.id, false) == null) {
FileLog.w("VoIPService: trying to open group call without call " + this.chat.id);
stopSelf();
return 2;
}
if (this.videoCall) {
if (Build.VERSION.SDK_INT < 23 || checkSelfPermission("android.permission.CAMERA") == 0) {
i3 = 0;
this.captureDevice[0] = NativeInstance.createVideoCapturer(this.localSink[0], this.isFrontFaceCamera ? 1 : 0);
if (longExtra2 != 0) {
this.videoState[0] = 1;
} else {
this.videoState[0] = 2;
}
} else {
i3 = 0;
this.videoState[0] = 1;
}
if (!this.isBtHeadsetConnected && !this.isHeadsetPlugged) {
setAudioOutput(i3);
}
}
if (this.user == null && this.chat == null) {
if (BuildVars.LOGS_ENABLED) {
FileLog.w("VoIPService: user == null AND chat == null");
}
stopSelf();
return 2;
}
sharedInstance = this;
synchronized (sync) {
if (setModeRunnable != null) {
Utilities.globalQueue.cancelRunnable(setModeRunnable);
setModeRunnable = null;
}
}
if (this.isOutgoing) {
if (this.user != null) {
dispatchStateChanged(14);
if (USE_CONNECTION_SERVICE) {
TelecomManager telecomManager = (TelecomManager) getSystemService("telecom");
Bundle bundle = new Bundle();
Bundle bundle2 = new Bundle();
bundle.putParcelable("android.telecom.extra.PHONE_ACCOUNT_HANDLE", addAccountToTelecomManager());
bundle2.putInt("call_type", 1);
bundle.putBundle("android.telecom.extra.OUTGOING_CALL_EXTRAS", bundle2);
ContactsController contactsController = ContactsController.getInstance(this.currentAccount);
TLRPC.User user = this.user;
contactsController.createOrUpdateConnectionServiceContact(user.id, user.first_name, user.last_name);
telecomManager.placeCall(Uri.fromParts("tel", "+99084" + this.user.id, null), bundle);
} else {
Runnable runnable = new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$onStartCommand$1();
}
};
this.delayedStartOutgoingCall = runnable;
AndroidUtilities.runOnUIThread(runnable, 2000L);
}
z2 = false;
} else {
this.micMute = true;
z2 = false;
startGroupCall(0, null, false);
if (!this.isBtHeadsetConnected && !this.isHeadsetPlugged) {
setAudioOutput(0);
}
}
if (intent.getBooleanExtra("start_incall_activity", z2)) {
Intent addFlags = new Intent(this, (Class<?>) LaunchActivity.class).setAction(this.user != null ? "voip" : "voip_chat").addFlags(268435456);
if (this.chat != null) {
addFlags.putExtra("currentAccount", this.currentAccount);
}
startActivity(addFlags);
}
} else {
NotificationCenter.getGlobalInstance().lambda$postNotificationNameOnUIThread$1(NotificationCenter.closeInCallActivity, new Object[0]);
TLRPC.PhoneCall phoneCall = callIShouldHavePutIntoIntent;
this.privateCall = phoneCall;
boolean z3 = phoneCall != null && phoneCall.video;
this.videoCall = z3;
if (z3) {
this.isVideoAvailable = true;
}
if (!z3 || this.isBtHeadsetConnected || this.isHeadsetPlugged) {
z = false;
} else {
z = false;
setAudioOutput(0);
}
callIShouldHavePutIntoIntent = null;
if (USE_CONNECTION_SERVICE) {
acknowledgeCall(z);
showNotification();
} else {
acknowledgeCall(true);
}
}
initializeAccountRelatedThings();
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$onStartCommand$2();
}
});
return 2;
}
public void lambda$onStartCommand$1() {
this.delayedStartOutgoingCall = null;
startOutgoingCall();
}
public void lambda$onStartCommand$2() {
NotificationCenter.getInstance(this.currentAccount).lambda$postNotificationNameOnUIThread$1(NotificationCenter.voipServiceCreated, new Object[0]);
}
public static boolean hasRtmpStream() {
return (getSharedInstance() == null || getSharedInstance().groupCall == null || !getSharedInstance().groupCall.call.rtmp_stream) ? false : true;
}
public static VoIPService getSharedInstance() {
return sharedInstance;
}
public TLRPC.User getUser() {
return this.user;
}
public TLRPC.Chat getChat() {
return this.chat;
}
public void setNoiseSupressionEnabled(boolean enabled) {
NativeInstance[] nativeInstanceArr = this.tgVoip;
if (nativeInstanceArr[0] == null) {
return;
}
nativeInstanceArr[0].setNoiseSuppressionEnabled(enabled);
}
public void setGroupCallHash(String hash) {
if (!this.currentGroupModeStreaming || TextUtils.isEmpty(hash) || hash.equals(this.joinHash)) {
return;
}
this.joinHash = hash;
createGroupInstance(0, false);
}
public long getCallerId() {
TLRPC.User user = this.user;
if (user != null) {
return user.id;
}
return -this.chat.id;
}
public void hangUp(int discard, Runnable onDone) {
int i = this.currentState;
declineIncomingCall((i == 16 || (i == 13 && this.isOutgoing)) ? 3 : 1, onDone);
if (this.groupCall == null || discard == 2) {
return;
}
if (discard == 1) {
TLRPC.ChatFull chatFull = MessagesController.getInstance(this.currentAccount).getChatFull(this.chat.id);
if (chatFull != null) {
chatFull.flags &= -2097153;
chatFull.call = null;
NotificationCenter.getInstance(this.currentAccount).lambda$postNotificationNameOnUIThread$1(NotificationCenter.groupCallUpdated, Long.valueOf(this.chat.id), Long.valueOf(this.groupCall.call.id), Boolean.FALSE);
}
TLRPC.TL_phone_discardGroupCall tL_phone_discardGroupCall = new TLRPC.TL_phone_discardGroupCall();
tL_phone_discardGroupCall.call = this.groupCall.getInputGroupCall();
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_phone_discardGroupCall, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.this.lambda$hangUp$3(tLObject, tL_error);
}
});
return;
}
TLRPC.TL_phone_leaveGroupCall tL_phone_leaveGroupCall = new TLRPC.TL_phone_leaveGroupCall();
tL_phone_leaveGroupCall.call = this.groupCall.getInputGroupCall();
tL_phone_leaveGroupCall.source = this.mySource[0];
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_phone_leaveGroupCall, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.this.lambda$hangUp$4(tLObject, tL_error);
}
});
}
public void lambda$hangUp$3(TLObject tLObject, TLRPC.TL_error tL_error) {
if (tLObject instanceof TLRPC.TL_updates) {
MessagesController.getInstance(this.currentAccount).processUpdates((TLRPC.TL_updates) tLObject, false);
}
}
public void lambda$hangUp$4(TLObject tLObject, TLRPC.TL_error tL_error) {
if (tLObject instanceof TLRPC.TL_updates) {
MessagesController.getInstance(this.currentAccount).processUpdates((TLRPC.TL_updates) tLObject, false);
}
}
private void startOutgoingCall() {
CallConnection callConnection;
if (USE_CONNECTION_SERVICE && (callConnection = this.systemCallConnection) != null) {
callConnection.setDialing();
}
configureDeviceForCall();
showNotification();
startConnectingSound();
dispatchStateChanged(14);
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.lambda$startOutgoingCall$5();
}
});
Utilities.random.nextBytes(new byte[256]);
TLRPC.TL_messages_getDhConfig tL_messages_getDhConfig = new TLRPC.TL_messages_getDhConfig();
tL_messages_getDhConfig.random_length = 256;
final MessagesStorage messagesStorage = MessagesStorage.getInstance(this.currentAccount);
tL_messages_getDhConfig.version = messagesStorage.getLastSecretVersion();
this.callReqId = ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_messages_getDhConfig, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.this.lambda$startOutgoingCall$10(messagesStorage, tLObject, tL_error);
}
}, 2);
}
public static void lambda$startOutgoingCall$5() {
NotificationCenter.getGlobalInstance().lambda$postNotificationNameOnUIThread$1(NotificationCenter.didStartedCall, new Object[0]);
}
public void lambda$startOutgoingCall$10(MessagesStorage messagesStorage, TLObject tLObject, TLRPC.TL_error tL_error) {
this.callReqId = 0;
if (this.endCallAfterRequest) {
callEnded();
return;
}
if (tL_error == null) {
TLRPC.messages_DhConfig messages_dhconfig = (TLRPC.messages_DhConfig) tLObject;
if (tLObject instanceof TLRPC.TL_messages_dhConfig) {
if (!Utilities.isGoodPrime(messages_dhconfig.p, messages_dhconfig.g)) {
callFailed();
return;
}
messagesStorage.setSecretPBytes(messages_dhconfig.p);
messagesStorage.setSecretG(messages_dhconfig.g);
messagesStorage.setLastSecretVersion(messages_dhconfig.version);
messagesStorage.saveSecretParams(messagesStorage.getLastSecretVersion(), messagesStorage.getSecretG(), messagesStorage.getSecretPBytes());
}
final byte[] bArr = new byte[256];
for (int i = 0; i < 256; i++) {
bArr[i] = (byte) (((byte) (Utilities.random.nextDouble() * 256.0d)) ^ messages_dhconfig.random[i]);
}
byte[] byteArray = BigInteger.valueOf(messagesStorage.getSecretG()).modPow(new BigInteger(1, bArr), new BigInteger(1, messagesStorage.getSecretPBytes())).toByteArray();
if (byteArray.length > 256) {
byte[] bArr2 = new byte[256];
System.arraycopy(byteArray, 1, bArr2, 0, 256);
byteArray = bArr2;
}
TLRPC.TL_phone_requestCall tL_phone_requestCall = new TLRPC.TL_phone_requestCall();
tL_phone_requestCall.user_id = MessagesController.getInstance(this.currentAccount).getInputUser(this.user);
TLRPC.TL_phoneCallProtocol tL_phoneCallProtocol = new TLRPC.TL_phoneCallProtocol();
tL_phone_requestCall.protocol = tL_phoneCallProtocol;
tL_phone_requestCall.video = this.videoCall;
tL_phoneCallProtocol.udp_p2p = true;
tL_phoneCallProtocol.udp_reflector = true;
tL_phoneCallProtocol.min_layer = 65;
tL_phoneCallProtocol.max_layer = Instance.getConnectionMaxLayer();
tL_phone_requestCall.protocol.library_versions.addAll(Instance.AVAILABLE_VERSIONS);
this.g_a = byteArray;
tL_phone_requestCall.g_a_hash = Utilities.computeSHA256(byteArray, 0, byteArray.length);
tL_phone_requestCall.random_id = Utilities.random.nextInt();
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_phone_requestCall, new RequestDelegate() {
@Override
public final void run(TLObject tLObject2, TLRPC.TL_error tL_error2) {
VoIPService.this.lambda$startOutgoingCall$9(bArr, tLObject2, tL_error2);
}
}, 2);
return;
}
if (BuildVars.LOGS_ENABLED) {
FileLog.e("Error on getDhConfig " + tL_error);
}
callFailed();
}
public void lambda$startOutgoingCall$9(final byte[] bArr, final TLObject tLObject, final TLRPC.TL_error tL_error) {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$startOutgoingCall$8(tL_error, tLObject, bArr);
}
});
}
public void lambda$startOutgoingCall$8(TLRPC.TL_error tL_error, TLObject tLObject, byte[] bArr) {
if (tL_error == null) {
this.privateCall = ((TLRPC.TL_phone_phoneCall) tLObject).phone_call;
this.a_or_b = bArr;
dispatchStateChanged(13);
if (this.endCallAfterRequest) {
hangUp();
return;
}
if (this.pendingUpdates.size() > 0 && this.privateCall != null) {
Iterator<TLRPC.PhoneCall> it = this.pendingUpdates.iterator();
while (it.hasNext()) {
onCallUpdated(it.next());
}
this.pendingUpdates.clear();
}
Runnable runnable = new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$startOutgoingCall$7();
}
};
this.timeoutRunnable = runnable;
AndroidUtilities.runOnUIThread(runnable, MessagesController.getInstance(this.currentAccount).callReceiveTimeout);
return;
}
if (tL_error.code == 400 && "PARTICIPANT_VERSION_OUTDATED".equals(tL_error.text)) {
callFailed(Instance.ERROR_PEER_OUTDATED);
return;
}
int i = tL_error.code;
if (i == 403) {
callFailed(Instance.ERROR_PRIVACY);
return;
}
if (i == 406) {
callFailed(Instance.ERROR_LOCALIZED);
return;
}
if (BuildVars.LOGS_ENABLED) {
FileLog.e("Error on phone.requestCall: " + tL_error);
}
callFailed();
}
public void lambda$startOutgoingCall$7() {
this.timeoutRunnable = null;
TLRPC.TL_phone_discardCall tL_phone_discardCall = new TLRPC.TL_phone_discardCall();
TLRPC.TL_inputPhoneCall tL_inputPhoneCall = new TLRPC.TL_inputPhoneCall();
tL_phone_discardCall.peer = tL_inputPhoneCall;
TLRPC.PhoneCall phoneCall = this.privateCall;
tL_inputPhoneCall.access_hash = phoneCall.access_hash;
tL_inputPhoneCall.id = phoneCall.id;
tL_phone_discardCall.reason = new TLRPC.TL_phoneCallDiscardReasonMissed();
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_phone_discardCall, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.this.lambda$startOutgoingCall$6(tLObject, tL_error);
}
}, 2);
}
public void lambda$startOutgoingCall$6(TLObject tLObject, TLRPC.TL_error tL_error) {
if (BuildVars.LOGS_ENABLED) {
if (tL_error != null) {
FileLog.e("error on phone.discardCall: " + tL_error);
} else {
FileLog.d("phone.discardCall " + tLObject);
}
}
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.callFailed();
}
});
}
private void acknowledgeCall(final boolean startRinging) {
if (this.privateCall instanceof TLRPC.TL_phoneCallDiscarded) {
if (BuildVars.LOGS_ENABLED) {
FileLog.w("Call " + this.privateCall.id + " was discarded before the service started, stopping");
}
stopSelf();
return;
}
if (Build.VERSION.SDK_INT >= 19 && XiaomiUtilities.isMIUI() && !XiaomiUtilities.isCustomPermissionGranted(XiaomiUtilities.OP_SHOW_WHEN_LOCKED) && ((KeyguardManager) getSystemService("keyguard")).inKeyguardRestrictedInputMode()) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("MIUI: no permission to show when locked but the screen is locked. ¯\\_(ツ)_/¯");
}
stopSelf();
return;
}
TLRPC.TL_phone_receivedCall tL_phone_receivedCall = new TLRPC.TL_phone_receivedCall();
TLRPC.TL_inputPhoneCall tL_inputPhoneCall = new TLRPC.TL_inputPhoneCall();
tL_phone_receivedCall.peer = tL_inputPhoneCall;
TLRPC.PhoneCall phoneCall = this.privateCall;
tL_inputPhoneCall.id = phoneCall.id;
tL_inputPhoneCall.access_hash = phoneCall.access_hash;
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_phone_receivedCall, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.this.lambda$acknowledgeCall$12(startRinging, tLObject, tL_error);
}
}, 2);
}
public void lambda$acknowledgeCall$12(final boolean z, final TLObject tLObject, final TLRPC.TL_error tL_error) {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$acknowledgeCall$11(tLObject, tL_error, z);
}
});
}
public void lambda$acknowledgeCall$11(TLObject tLObject, TLRPC.TL_error tL_error, boolean z) {
if (sharedInstance == null) {
return;
}
if (BuildVars.LOGS_ENABLED) {
FileLog.w("receivedCall response = " + tLObject);
}
if (tL_error != null) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("error on receivedCall: " + tL_error);
}
stopSelf();
return;
}
if (USE_CONNECTION_SERVICE) {
ContactsController contactsController = ContactsController.getInstance(this.currentAccount);
TLRPC.User user = this.user;
contactsController.createOrUpdateConnectionServiceContact(user.id, user.first_name, user.last_name);
TelecomManager telecomManager = (TelecomManager) getSystemService("telecom");
Bundle bundle = new Bundle();
bundle.putInt("call_type", 1);
telecomManager.addNewIncomingCall(addAccountToTelecomManager(), bundle);
}
if (z) {
startRinging();
}
}
private boolean isRinging() {
return this.currentState == 15;
}
public boolean isJoined() {
int i = this.currentState;
return (i == 1 || i == 6) ? false : true;
}
public void requestVideoCall(boolean screencast) {
NativeInstance[] nativeInstanceArr = this.tgVoip;
int i = 0;
if (nativeInstanceArr[0] == null) {
return;
}
if (!screencast) {
long[] jArr = this.captureDevice;
if (jArr[0] != 0) {
nativeInstanceArr[0].setupOutgoingVideoCreated(jArr[0]);
this.destroyCaptureDevice[0] = false;
this.isPrivateScreencast = screencast;
}
}
NativeInstance nativeInstance = nativeInstanceArr[0];
ProxyVideoSink proxyVideoSink = this.localSink[0];
if (screencast) {
i = 2;
} else if (this.isFrontFaceCamera) {
i = 1;
}
nativeInstance.setupOutgoingVideo(proxyVideoSink, i);
this.isPrivateScreencast = screencast;
}
public void switchCamera() {
NativeInstance[] nativeInstanceArr = this.tgVoip;
if (nativeInstanceArr[0] == null || !nativeInstanceArr[0].hasVideoCapturer() || this.switchingCamera) {
long[] jArr = this.captureDevice;
if (jArr[0] == 0 || this.switchingCamera) {
return;
}
NativeInstance.switchCameraCapturer(jArr[0], !this.isFrontFaceCamera);
return;
}
this.switchingCamera = true;
this.tgVoip[0].switchCamera(!this.isFrontFaceCamera);
}
public boolean isSwitchingCamera() {
return this.switchingCamera;
}
public void createCaptureDevice(boolean z) {
?? r1 = z ? 2 : this.isFrontFaceCamera;
if (this.groupCall == null) {
if (!this.isPrivateScreencast && z) {
setVideoState(false, 0);
}
this.isPrivateScreencast = z;
NativeInstance[] nativeInstanceArr = this.tgVoip;
if (nativeInstanceArr[0] != null) {
nativeInstanceArr[0].clearVideoCapturer();
}
}
if (z) {
if (this.groupCall != null) {
long[] jArr = this.captureDevice;
if (jArr[z ? 1 : 0] != 0) {
return;
}
jArr[z ? 1 : 0] = NativeInstance.createVideoCapturer(this.localSink[z ? 1 : 0], r1);
createGroupInstance(1, false);
setVideoState(true, 2);
AccountInstance.getInstance(this.currentAccount).getNotificationCenter().lambda$postNotificationNameOnUIThread$1(NotificationCenter.groupCallScreencastStateChanged, new Object[0]);
return;
}
requestVideoCall(true);
setVideoState(true, 2);
if (VoIPFragment.getInstance() != null) {
VoIPFragment.getInstance().onScreenCastStart();
return;
}
return;
}
long[] jArr2 = this.captureDevice;
if (jArr2[z ? 1 : 0] != 0 || this.tgVoip[z ? 1 : 0] == null) {
NativeInstance[] nativeInstanceArr2 = this.tgVoip;
if (nativeInstanceArr2[z ? 1 : 0] != null && jArr2[z ? 1 : 0] != 0) {
nativeInstanceArr2[z ? 1 : 0].activateVideoCapturer(jArr2[z ? 1 : 0]);
}
if (this.captureDevice[z ? 1 : 0] != 0) {
return;
}
}
this.captureDevice[z ? 1 : 0] = NativeInstance.createVideoCapturer(this.localSink[z ? 1 : 0], r1);
}
public void setupCaptureDevice(boolean z, boolean z2) {
if (!z) {
long[] jArr = this.captureDevice;
if (jArr[z ? 1 : 0] == 0) {
return;
}
NativeInstance[] nativeInstanceArr = this.tgVoip;
if (nativeInstanceArr[z ? 1 : 0] == null) {
return;
}
nativeInstanceArr[z ? 1 : 0].setupOutgoingVideoCreated(jArr[z ? 1 : 0]);
this.destroyCaptureDevice[z ? 1 : 0] = false;
this.videoState[z ? 1 : 0] = 2;
}
if (this.micMute == z2) {
setMicMute(!z2, false, false);
this.micSwitching = true;
}
if (this.groupCall != null) {
editCallMember(UserConfig.getInstance(this.currentAccount).getCurrentUser(), Boolean.valueOf(!z2), Boolean.valueOf(this.videoState[0] != 2), null, null, new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$setupCaptureDevice$13();
}
});
}
}
public void lambda$setupCaptureDevice$13() {
this.micSwitching = false;
}
public void clearCamera() {
NativeInstance[] nativeInstanceArr = this.tgVoip;
if (nativeInstanceArr[0] != null) {
nativeInstanceArr[0].clearVideoCapturer();
}
}
public void setVideoState(boolean z, int i) {
int i2;
char c = this.groupCall != null ? z ? 1 : 0 : (char) 0;
NativeInstance[] nativeInstanceArr = this.tgVoip;
if (nativeInstanceArr[c] == null) {
long[] jArr = this.captureDevice;
if (jArr[z ? 1 : 0] != 0) {
int[] iArr = this.videoState;
iArr[c] = i;
NativeInstance.setVideoStateCapturer(jArr[z ? 1 : 0], iArr[c]);
return;
} else {
if (i != 2 || (i2 = this.currentState) == 17 || i2 == 11) {
return;
}
jArr[z ? 1 : 0] = NativeInstance.createVideoCapturer(this.localSink[c], this.isFrontFaceCamera ? 1 : 0);
this.videoState[c] = 2;
return;
}
}
int[] iArr2 = this.videoState;
iArr2[c] = i;
nativeInstanceArr[c].setVideoState(iArr2[c]);
long[] jArr2 = this.captureDevice;
if (jArr2[z ? 1 : 0] != 0) {
NativeInstance.setVideoStateCapturer(jArr2[z ? 1 : 0], this.videoState[c]);
}
if (z) {
return;
}
if (this.groupCall != null) {
editCallMember(UserConfig.getInstance(this.currentAccount).getCurrentUser(), null, Boolean.valueOf(this.videoState[0] != 2), null, null, null);
}
checkIsNear();
}
public void stopScreenCapture() {
if (this.groupCall == null || this.videoState[1] != 2) {
return;
}
TLRPC.TL_phone_leaveGroupCallPresentation tL_phone_leaveGroupCallPresentation = new TLRPC.TL_phone_leaveGroupCallPresentation();
tL_phone_leaveGroupCallPresentation.call = this.groupCall.getInputGroupCall();
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_phone_leaveGroupCallPresentation, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.this.lambda$stopScreenCapture$14(tLObject, tL_error);
}
});
NativeInstance nativeInstance = this.tgVoip[1];
if (nativeInstance != null) {
Utilities.globalQueue.postRunnable(new VoIPService$$ExternalSyntheticLambda5(nativeInstance));
}
this.mySource[1] = 0;
this.tgVoip[1] = null;
this.destroyCaptureDevice[1] = true;
this.captureDevice[1] = 0;
this.videoState[1] = 0;
AccountInstance.getInstance(this.currentAccount).getNotificationCenter().lambda$postNotificationNameOnUIThread$1(NotificationCenter.groupCallScreencastStateChanged, new Object[0]);
}
public void lambda$stopScreenCapture$14(TLObject tLObject, TLRPC.TL_error tL_error) {
if (tLObject != null) {
MessagesController.getInstance(this.currentAccount).processUpdates((TLRPC.Updates) tLObject, false);
}
}
public int getVideoState(boolean z) {
return this.videoState[z ? 1 : 0];
}
public void setSinks(VideoSink local, VideoSink remote) {
setSinks(local, false, remote);
}
public void setSinks(VideoSink videoSink, boolean z, VideoSink videoSink2) {
ProxyVideoSink proxyVideoSink = this.localSink[z ? 1 : 0];
ProxyVideoSink proxyVideoSink2 = this.remoteSink[z ? 1 : 0];
if (proxyVideoSink != null) {
proxyVideoSink.setTarget(videoSink);
}
if (proxyVideoSink2 != null) {
proxyVideoSink2.setTarget(videoSink2);
}
}
public void setLocalSink(VideoSink local, boolean screencast) {
if (screencast) {
return;
}
this.localSink[0].setTarget(local);
}
public void setRemoteSink(VideoSink videoSink, boolean z) {
this.remoteSink[z ? 1 : 0].setTarget(videoSink);
}
public ProxyVideoSink addRemoteSink(TLRPC.TL_groupCallParticipant participant, boolean screencast, VideoSink remote, VideoSink background) {
if (this.tgVoip[0] == null) {
return null;
}
String str = screencast ? participant.presentationEndpoint : participant.videoEndpoint;
if (str == null) {
return null;
}
ProxyVideoSink proxyVideoSink = this.remoteSinks.get(str);
if (proxyVideoSink != null && proxyVideoSink.target == remote) {
return proxyVideoSink;
}
if (proxyVideoSink == null) {
proxyVideoSink = this.proxyVideoSinkLruCache.remove(str);
}
if (proxyVideoSink == null) {
proxyVideoSink = new ProxyVideoSink();
}
if (remote != null) {
proxyVideoSink.setTarget(remote);
}
if (background != null) {
proxyVideoSink.setBackground(background);
}
this.remoteSinks.put(str, proxyVideoSink);
proxyVideoSink.nativeInstance = this.tgVoip[0].addIncomingVideoOutput(1, str, createSsrcGroups(screencast ? participant.presentation : participant.video), proxyVideoSink);
return proxyVideoSink;
}
private NativeInstance.SsrcGroup[] createSsrcGroups(TLRPC.TL_groupCallParticipantVideo video) {
if (video.source_groups.isEmpty()) {
return null;
}
int size = video.source_groups.size();
NativeInstance.SsrcGroup[] ssrcGroupArr = new NativeInstance.SsrcGroup[size];
for (int i = 0; i < size; i++) {
ssrcGroupArr[i] = new NativeInstance.SsrcGroup();
TLRPC.TL_groupCallParticipantVideoSourceGroup tL_groupCallParticipantVideoSourceGroup = video.source_groups.get(i);
ssrcGroupArr[i].semantics = tL_groupCallParticipantVideoSourceGroup.semantics;
ssrcGroupArr[i].ssrcs = new int[tL_groupCallParticipantVideoSourceGroup.sources.size()];
for (int i2 = 0; i2 < ssrcGroupArr[i].ssrcs.length; i2++) {
ssrcGroupArr[i].ssrcs[i2] = tL_groupCallParticipantVideoSourceGroup.sources.get(i2).intValue();
}
}
return ssrcGroupArr;
}
public void requestFullScreen(TLRPC.TL_groupCallParticipant participant, boolean full, boolean screencast) {
String str = screencast ? participant.presentationEndpoint : participant.videoEndpoint;
if (str == null) {
return;
}
if (full) {
this.tgVoip[0].setVideoEndpointQuality(str, 2);
} else {
this.tgVoip[0].setVideoEndpointQuality(str, 1);
}
}
public void removeRemoteSink(TLRPC.TL_groupCallParticipant participant, boolean presentation) {
if (presentation) {
ProxyVideoSink remove = this.remoteSinks.remove(participant.presentationEndpoint);
if (remove != null) {
this.tgVoip[0].removeIncomingVideoOutput(remove.nativeInstance);
return;
}
return;
}
ProxyVideoSink remove2 = this.remoteSinks.remove(participant.videoEndpoint);
if (remove2 != null) {
this.tgVoip[0].removeIncomingVideoOutput(remove2.nativeInstance);
}
}
public boolean isFullscreen(TLRPC.TL_groupCallParticipant tL_groupCallParticipant, boolean z) {
if (this.currentBackgroundSink[z ? 1 : 0] != null) {
if (TextUtils.equals(this.currentBackgroundEndpointId[z ? 1 : 0], z ? tL_groupCallParticipant.presentationEndpoint : tL_groupCallParticipant.videoEndpoint)) {
return true;
}
}
return false;
}
public void setBackgroundSinks(VideoSink local, VideoSink remote) {
this.localSink[0].setBackground(local);
this.remoteSink[0].setBackground(remote);
}
public void swapSinks() {
this.localSink[0].swap();
this.remoteSink[0].swap();
}
public boolean isHangingUp() {
return this.currentState == 10;
}
public void onSignalingData(TLRPC.TL_updatePhoneCallSignalingData data) {
if (this.user != null) {
NativeInstance[] nativeInstanceArr = this.tgVoip;
if (nativeInstanceArr[0] == null || nativeInstanceArr[0].isGroup() || getCallID() != data.phone_call_id) {
return;
}
this.tgVoip[0].onSignalingDataReceive(data.data);
}
}
public long getSelfId() {
TLRPC.InputPeer inputPeer = this.groupCallPeer;
if (inputPeer == null) {
return UserConfig.getInstance(this.currentAccount).clientUserId;
}
if (inputPeer instanceof TLRPC.TL_inputPeerUser) {
return inputPeer.user_id;
}
if (inputPeer instanceof TLRPC.TL_inputPeerChannel) {
return -inputPeer.channel_id;
}
return -inputPeer.chat_id;
}
public void onGroupCallParticipantsUpdate(TLRPC.TL_updateGroupCallParticipants update) {
ChatObject.Call call;
if (this.chat == null || (call = this.groupCall) == null || call.call.id != update.call.id) {
return;
}
long selfId = getSelfId();
int size = update.participants.size();
for (int i = 0; i < size; i++) {
TLRPC.TL_groupCallParticipant tL_groupCallParticipant = update.participants.get(i);
if (tL_groupCallParticipant.left) {
int i2 = tL_groupCallParticipant.source;
if (i2 != 0 && i2 == this.mySource[0]) {
int i3 = 0;
for (int i4 = 0; i4 < size; i4++) {
TLRPC.TL_groupCallParticipant tL_groupCallParticipant2 = update.participants.get(i4);
if (tL_groupCallParticipant2.self || tL_groupCallParticipant2.source == this.mySource[0]) {
i3++;
}
}
if (i3 > 1) {
hangUp(2);
return;
}
}
} else if (MessageObject.getPeerId(tL_groupCallParticipant.peer) == selfId) {
int i5 = tL_groupCallParticipant.source;
int[] iArr = this.mySource;
if (i5 != iArr[0] && iArr[0] != 0 && i5 != 0) {
if (BuildVars.LOGS_ENABLED) {
FileLog.d("source mismatch my = " + this.mySource[0] + " psrc = " + tL_groupCallParticipant.source);
}
hangUp(2);
return;
}
if (ChatObject.isChannel(this.chat) && this.currentGroupModeStreaming && tL_groupCallParticipant.can_self_unmute) {
this.switchingStream = true;
createGroupInstance(0, false);
}
if (tL_groupCallParticipant.muted) {
setMicMute(true, false, false);
}
} else {
continue;
}
}
}
public void onGroupCallUpdated(org.telegram.tgnet.TLRPC.GroupCall r6) {
throw new UnsupportedOperationException("Method not decompiled: org.telegram.messenger.voip.VoIPService.onGroupCallUpdated(org.telegram.tgnet.TLRPC$GroupCall):void");
}
public void onCallUpdated(org.telegram.tgnet.TLRPC.PhoneCall r7) {
throw new UnsupportedOperationException("Method not decompiled: org.telegram.messenger.voip.VoIPService.onCallUpdated(org.telegram.tgnet.TLRPC$PhoneCall):void");
}
public void lambda$onCallUpdated$15() {
this.soundPool.play(this.spBusyId, 1.0f, 1.0f, 0, -1, 1.0f);
}
public void lambda$onCallUpdated$16() {
int i = this.spPlayId;
if (i != 0) {
this.soundPool.stop(i);
}
this.spPlayId = this.soundPool.play(this.spRingbackID, 1.0f, 1.0f, 0, -1, 1.0f);
}
public void lambda$onCallUpdated$17() {
this.timeoutRunnable = null;
declineIncomingCall(3, null);
}
private void startRatingActivity() {
try {
PendingIntent.getActivity(this, 0, new Intent(this, (Class<?>) VoIPFeedbackActivity.class).putExtra("call_id", this.privateCall.id).putExtra("call_access_hash", this.privateCall.access_hash).putExtra("call_video", this.privateCall.video).putExtra("account", this.currentAccount).addFlags(805306368), 33554432).send();
} catch (Exception e) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("Error starting incall activity", e);
}
}
}
public void sendCallRating(int rating) {
TLRPC.PhoneCall phoneCall = this.privateCall;
VoIPHelper.sendCallRating(phoneCall.id, phoneCall.access_hash, this.currentAccount, rating);
}
public byte[] getEncryptionKey() {
return this.authKey;
}
private void processAcceptedCall() {
byte[] bArr;
dispatchStateChanged(12);
BigInteger bigInteger = new BigInteger(1, MessagesStorage.getInstance(this.currentAccount).getSecretPBytes());
BigInteger bigInteger2 = new BigInteger(1, this.privateCall.g_b);
if (!Utilities.isGoodGaAndGb(bigInteger2, bigInteger)) {
if (BuildVars.LOGS_ENABLED) {
FileLog.w("stopping VoIP service, bad Ga and Gb");
}
callFailed();
return;
}
byte[] byteArray = bigInteger2.modPow(new BigInteger(1, this.a_or_b), bigInteger).toByteArray();
if (byteArray.length > 256) {
bArr = new byte[256];
System.arraycopy(byteArray, byteArray.length - 256, bArr, 0, 256);
} else {
if (byteArray.length < 256) {
bArr = new byte[256];
System.arraycopy(byteArray, 0, bArr, 256 - byteArray.length, byteArray.length);
for (int i = 0; i < 256 - byteArray.length; i++) {
bArr[i] = 0;
}
}
byte[] computeSHA1 = Utilities.computeSHA1(byteArray);
byte[] bArr2 = new byte[8];
System.arraycopy(computeSHA1, computeSHA1.length - 8, bArr2, 0, 8);
long bytesToLong = Utilities.bytesToLong(bArr2);
this.authKey = byteArray;
this.keyFingerprint = bytesToLong;
TLRPC.TL_phone_confirmCall tL_phone_confirmCall = new TLRPC.TL_phone_confirmCall();
tL_phone_confirmCall.g_a = this.g_a;
tL_phone_confirmCall.key_fingerprint = bytesToLong;
TLRPC.TL_inputPhoneCall tL_inputPhoneCall = new TLRPC.TL_inputPhoneCall();
tL_phone_confirmCall.peer = tL_inputPhoneCall;
TLRPC.PhoneCall phoneCall = this.privateCall;
tL_inputPhoneCall.id = phoneCall.id;
tL_inputPhoneCall.access_hash = phoneCall.access_hash;
TLRPC.TL_phoneCallProtocol tL_phoneCallProtocol = new TLRPC.TL_phoneCallProtocol();
tL_phone_confirmCall.protocol = tL_phoneCallProtocol;
tL_phoneCallProtocol.max_layer = Instance.getConnectionMaxLayer();
TLRPC.TL_phoneCallProtocol tL_phoneCallProtocol2 = tL_phone_confirmCall.protocol;
tL_phoneCallProtocol2.min_layer = 65;
tL_phoneCallProtocol2.udp_reflector = true;
tL_phoneCallProtocol2.udp_p2p = true;
tL_phoneCallProtocol2.library_versions.addAll(Instance.AVAILABLE_VERSIONS);
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_phone_confirmCall, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.this.lambda$processAcceptedCall$19(tLObject, tL_error);
}
});
}
byteArray = bArr;
byte[] computeSHA12 = Utilities.computeSHA1(byteArray);
byte[] bArr22 = new byte[8];
System.arraycopy(computeSHA12, computeSHA12.length - 8, bArr22, 0, 8);
long bytesToLong2 = Utilities.bytesToLong(bArr22);
this.authKey = byteArray;
this.keyFingerprint = bytesToLong2;
TLRPC.TL_phone_confirmCall tL_phone_confirmCall2 = new TLRPC.TL_phone_confirmCall();
tL_phone_confirmCall2.g_a = this.g_a;
tL_phone_confirmCall2.key_fingerprint = bytesToLong2;
TLRPC.TL_inputPhoneCall tL_inputPhoneCall2 = new TLRPC.TL_inputPhoneCall();
tL_phone_confirmCall2.peer = tL_inputPhoneCall2;
TLRPC.PhoneCall phoneCall2 = this.privateCall;
tL_inputPhoneCall2.id = phoneCall2.id;
tL_inputPhoneCall2.access_hash = phoneCall2.access_hash;
TLRPC.TL_phoneCallProtocol tL_phoneCallProtocol3 = new TLRPC.TL_phoneCallProtocol();
tL_phone_confirmCall2.protocol = tL_phoneCallProtocol3;
tL_phoneCallProtocol3.max_layer = Instance.getConnectionMaxLayer();
TLRPC.TL_phoneCallProtocol tL_phoneCallProtocol22 = tL_phone_confirmCall2.protocol;
tL_phoneCallProtocol22.min_layer = 65;
tL_phoneCallProtocol22.udp_reflector = true;
tL_phoneCallProtocol22.udp_p2p = true;
tL_phoneCallProtocol22.library_versions.addAll(Instance.AVAILABLE_VERSIONS);
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_phone_confirmCall2, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.this.lambda$processAcceptedCall$19(tLObject, tL_error);
}
});
}
public void lambda$processAcceptedCall$19(final TLObject tLObject, final TLRPC.TL_error tL_error) {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$processAcceptedCall$18(tL_error, tLObject);
}
});
}
public void lambda$processAcceptedCall$18(TLRPC.TL_error tL_error, TLObject tLObject) {
if (tL_error != null) {
callFailed();
} else {
this.privateCall = ((TLRPC.TL_phone_phoneCall) tLObject).phone_call;
initiateActualEncryptedCall();
}
}
private int convertDataSavingMode(int i) {
return i != 3 ? i : ApplicationLoader.isRoaming() ? 1 : 0;
}
public void migrateToChat(TLRPC.Chat newChat) {
this.chat = newChat;
}
public void setGroupCallPeer(TLRPC.InputPeer peer) {
ChatObject.Call call = this.groupCall;
if (call == null) {
return;
}
this.groupCallPeer = peer;
call.setSelfPeer(peer);
TLRPC.ChatFull chatFull = MessagesController.getInstance(this.currentAccount).getChatFull(this.groupCall.chatId);
if (chatFull != null) {
TLRPC.Peer peer2 = this.groupCall.selfPeer;
chatFull.groupcall_default_join_as = peer2;
if (peer2 != null) {
if (chatFull instanceof TLRPC.TL_chatFull) {
chatFull.flags |= 32768;
} else {
chatFull.flags |= 67108864;
}
} else if (chatFull instanceof TLRPC.TL_chatFull) {
chatFull.flags &= -32769;
} else {
chatFull.flags &= -67108865;
}
}
createGroupInstance(0, true);
if (this.videoState[1] == 2) {
createGroupInstance(1, true);
}
}
private void startGroupCall(final int ssrc, String json, final boolean create) {
if (sharedInstance != this) {
return;
}
if (this.createGroupCall) {
ChatObject.Call call = new ChatObject.Call();
this.groupCall = call;
call.call = new TLRPC.TL_groupCall();
ChatObject.Call call2 = this.groupCall;
TLRPC.GroupCall groupCall = call2.call;
groupCall.participants_count = 0;
groupCall.version = 1;
groupCall.can_start_video = true;
groupCall.can_change_join_muted = true;
call2.chatId = this.chat.id;
call2.currentAccount = AccountInstance.getInstance(this.currentAccount);
this.groupCall.setSelfPeer(this.groupCallPeer);
this.groupCall.createNoVideoParticipant();
dispatchStateChanged(6);
TLRPC.TL_phone_createGroupCall tL_phone_createGroupCall = new TLRPC.TL_phone_createGroupCall();
tL_phone_createGroupCall.peer = MessagesController.getInputPeer(this.chat);
tL_phone_createGroupCall.random_id = Utilities.random.nextInt();
int i = this.scheduleDate;
if (i != 0) {
tL_phone_createGroupCall.schedule_date = i;
tL_phone_createGroupCall.flags |= 2;
}
this.groupCallBottomSheetLatch = new CountDownLatch(1);
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_phone_createGroupCall, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.this.lambda$startGroupCall$22(tLObject, tL_error);
}
}, 2);
this.createGroupCall = false;
return;
}
if (json == null) {
if (this.groupCall == null) {
ChatObject.Call groupCall2 = MessagesController.getInstance(this.currentAccount).getGroupCall(this.chat.id, false);
this.groupCall = groupCall2;
if (groupCall2 != null) {
groupCall2.setSelfPeer(this.groupCallPeer);
}
}
configureDeviceForCall();
showNotification();
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.lambda$startGroupCall$23();
}
});
createGroupInstance(0, false);
return;
}
if (getSharedInstance() == null || this.groupCall == null) {
return;
}
dispatchStateChanged(1);
if (BuildVars.LOGS_ENABLED) {
FileLog.d("initital source = " + ssrc);
}
TLRPC.TL_phone_joinGroupCall tL_phone_joinGroupCall = new TLRPC.TL_phone_joinGroupCall();
tL_phone_joinGroupCall.muted = true;
tL_phone_joinGroupCall.video_stopped = this.videoState[0] != 2;
tL_phone_joinGroupCall.call = this.groupCall.getInputGroupCall();
TLRPC.TL_dataJSON tL_dataJSON = new TLRPC.TL_dataJSON();
tL_phone_joinGroupCall.params = tL_dataJSON;
tL_dataJSON.data = json;
if (!TextUtils.isEmpty(this.joinHash)) {
tL_phone_joinGroupCall.invite_hash = this.joinHash;
tL_phone_joinGroupCall.flags |= 2;
}
TLRPC.InputPeer inputPeer = this.groupCallPeer;
if (inputPeer != null) {
tL_phone_joinGroupCall.join_as = inputPeer;
} else {
TLRPC.TL_inputPeerUser tL_inputPeerUser = new TLRPC.TL_inputPeerUser();
tL_phone_joinGroupCall.join_as = tL_inputPeerUser;
tL_inputPeerUser.user_id = AccountInstance.getInstance(this.currentAccount).getUserConfig().getClientUserId();
}
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_phone_joinGroupCall, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.this.lambda$startGroupCall$28(ssrc, create, tLObject, tL_error);
}
});
}
public void lambda$startGroupCall$22(TLObject tLObject, final TLRPC.TL_error tL_error) {
if (tLObject != null) {
try {
this.groupCallBottomSheetLatch.await(800L, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
FileLog.e(e);
}
TLRPC.Updates updates = (TLRPC.Updates) tLObject;
int i = 0;
while (true) {
if (i >= updates.updates.size()) {
break;
}
TLRPC.Update update = updates.updates.get(i);
if (update instanceof TLRPC.TL_updateGroupCall) {
final TLRPC.TL_updateGroupCall tL_updateGroupCall = (TLRPC.TL_updateGroupCall) update;
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$startGroupCall$20(tL_updateGroupCall);
}
});
break;
}
i++;
}
MessagesController.getInstance(this.currentAccount).processUpdates(updates, false);
return;
}
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$startGroupCall$21(tL_error);
}
});
}
public void lambda$startGroupCall$20(TLRPC.TL_updateGroupCall tL_updateGroupCall) {
if (sharedInstance == null) {
return;
}
TLRPC.GroupCall groupCall = this.groupCall.call;
TLRPC.GroupCall groupCall2 = tL_updateGroupCall.call;
groupCall.access_hash = groupCall2.access_hash;
groupCall.id = groupCall2.id;
MessagesController messagesController = MessagesController.getInstance(this.currentAccount);
ChatObject.Call call = this.groupCall;
messagesController.putGroupCall(call.chatId, call);
startGroupCall(0, null, false);
}
public void lambda$startGroupCall$21(TLRPC.TL_error tL_error) {
NotificationCenter.getInstance(this.currentAccount).lambda$postNotificationNameOnUIThread$1(NotificationCenter.needShowAlert, 6, tL_error.text);
hangUp(0);
}
public static void lambda$startGroupCall$23() {
NotificationCenter.getGlobalInstance().lambda$postNotificationNameOnUIThread$1(NotificationCenter.didStartedCall, new Object[0]);
}
public void lambda$startGroupCall$24(int i) {
this.mySource[0] = i;
}
public void lambda$startGroupCall$28(final int i, final boolean z, TLObject tLObject, final TLRPC.TL_error tL_error) {
if (tLObject != null) {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$startGroupCall$24(i);
}
});
TLRPC.Updates updates = (TLRPC.Updates) tLObject;
long selfId = getSelfId();
int size = updates.updates.size();
for (int i2 = 0; i2 < size; i2++) {
TLRPC.Update update = updates.updates.get(i2);
if (update instanceof TLRPC.TL_updateGroupCallParticipants) {
TLRPC.TL_updateGroupCallParticipants tL_updateGroupCallParticipants = (TLRPC.TL_updateGroupCallParticipants) update;
int size2 = tL_updateGroupCallParticipants.participants.size();
int i3 = 0;
while (true) {
if (i3 < size2) {
final TLRPC.TL_groupCallParticipant tL_groupCallParticipant = tL_updateGroupCallParticipants.participants.get(i3);
if (MessageObject.getPeerId(tL_groupCallParticipant.peer) == selfId) {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$startGroupCall$25(tL_groupCallParticipant);
}
});
if (BuildVars.LOGS_ENABLED) {
FileLog.d("join source = " + tL_groupCallParticipant.source);
}
} else {
i3++;
}
}
}
} else if (update instanceof TLRPC.TL_updateGroupCallConnection) {
TLRPC.TL_updateGroupCallConnection tL_updateGroupCallConnection = (TLRPC.TL_updateGroupCallConnection) update;
if (!tL_updateGroupCallConnection.presentation) {
this.myParams = tL_updateGroupCallConnection.params;
}
}
}
MessagesController.getInstance(this.currentAccount).processUpdates(updates, false);
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$startGroupCall$26(z);
}
});
startGroupCheckShortpoll();
return;
}
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$startGroupCall$27(tL_error);
}
});
}
public void lambda$startGroupCall$25(TLRPC.TL_groupCallParticipant tL_groupCallParticipant) {
this.mySource[0] = tL_groupCallParticipant.source;
}
public void lambda$startGroupCall$26(boolean z) {
this.groupCall.loadMembers(z);
}
public void lambda$startGroupCall$27(TLRPC.TL_error tL_error) {
if ("JOIN_AS_PEER_INVALID".equals(tL_error.text)) {
TLRPC.ChatFull chatFull = MessagesController.getInstance(this.currentAccount).getChatFull(this.chat.id);
if (chatFull != null) {
if (chatFull instanceof TLRPC.TL_chatFull) {
chatFull.flags &= -32769;
} else {
chatFull.flags &= -67108865;
}
chatFull.groupcall_default_join_as = null;
JoinCallAlert.resetCache();
}
hangUp(2);
return;
}
if ("GROUPCALL_SSRC_DUPLICATE_MUCH".equals(tL_error.text)) {
createGroupInstance(0, false);
return;
}
if ("GROUPCALL_INVALID".equals(tL_error.text)) {
MessagesController.getInstance(this.currentAccount).loadFullChat(this.chat.id, 0, true);
}
NotificationCenter.getInstance(this.currentAccount).lambda$postNotificationNameOnUIThread$1(NotificationCenter.needShowAlert, 6, tL_error.text);
hangUp(0);
}
private void startScreenCapture(final int ssrc, String json) {
if (getSharedInstance() == null || this.groupCall == null) {
return;
}
this.mySource[1] = 0;
TLRPC.TL_phone_joinGroupCallPresentation tL_phone_joinGroupCallPresentation = new TLRPC.TL_phone_joinGroupCallPresentation();
tL_phone_joinGroupCallPresentation.call = this.groupCall.getInputGroupCall();
TLRPC.TL_dataJSON tL_dataJSON = new TLRPC.TL_dataJSON();
tL_phone_joinGroupCallPresentation.params = tL_dataJSON;
tL_dataJSON.data = json;
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_phone_joinGroupCallPresentation, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.this.lambda$startScreenCapture$32(ssrc, tLObject, tL_error);
}
});
}
public void lambda$startScreenCapture$29(int i) {
this.mySource[1] = i;
}
public void lambda$startScreenCapture$32(final int i, TLObject tLObject, final TLRPC.TL_error tL_error) {
if (tLObject != null) {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$startScreenCapture$29(i);
}
});
final TLRPC.Updates updates = (TLRPC.Updates) tLObject;
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$startScreenCapture$30(updates);
}
});
MessagesController.getInstance(this.currentAccount).processUpdates(updates, false);
startGroupCheckShortpoll();
return;
}
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$startScreenCapture$31(tL_error);
}
});
}
public void lambda$startScreenCapture$30(TLRPC.Updates updates) {
if (this.tgVoip[1] != null) {
long selfId = getSelfId();
int size = updates.updates.size();
for (int i = 0; i < size; i++) {
TLRPC.Update update = updates.updates.get(i);
if (update instanceof TLRPC.TL_updateGroupCallConnection) {
TLRPC.TL_updateGroupCallConnection tL_updateGroupCallConnection = (TLRPC.TL_updateGroupCallConnection) update;
if (tL_updateGroupCallConnection.presentation) {
this.tgVoip[1].setJoinResponsePayload(tL_updateGroupCallConnection.params.data);
}
} else if (update instanceof TLRPC.TL_updateGroupCallParticipants) {
TLRPC.TL_updateGroupCallParticipants tL_updateGroupCallParticipants = (TLRPC.TL_updateGroupCallParticipants) update;
int size2 = tL_updateGroupCallParticipants.participants.size();
int i2 = 0;
while (true) {
if (i2 < size2) {
TLRPC.TL_groupCallParticipant tL_groupCallParticipant = tL_updateGroupCallParticipants.participants.get(i2);
if (MessageObject.getPeerId(tL_groupCallParticipant.peer) == selfId) {
TLRPC.TL_groupCallParticipantVideo tL_groupCallParticipantVideo = tL_groupCallParticipant.presentation;
if (tL_groupCallParticipantVideo != null) {
if ((tL_groupCallParticipantVideo.flags & 2) != 0) {
this.mySource[1] = tL_groupCallParticipantVideo.audio_source;
} else {
int size3 = tL_groupCallParticipantVideo.source_groups.size();
for (int i3 = 0; i3 < size3; i3++) {
TLRPC.TL_groupCallParticipantVideoSourceGroup tL_groupCallParticipantVideoSourceGroup = tL_groupCallParticipant.presentation.source_groups.get(i3);
if (tL_groupCallParticipantVideoSourceGroup.sources.size() > 0) {
this.mySource[1] = tL_groupCallParticipantVideoSourceGroup.sources.get(0).intValue();
}
}
}
}
} else {
i2++;
}
}
}
}
}
}
}
public void lambda$startScreenCapture$31(TLRPC.TL_error tL_error) {
if ("GROUPCALL_VIDEO_TOO_MUCH".equals(tL_error.text)) {
this.groupCall.reloadGroupCall();
return;
}
if ("JOIN_AS_PEER_INVALID".equals(tL_error.text)) {
TLRPC.ChatFull chatFull = MessagesController.getInstance(this.currentAccount).getChatFull(this.chat.id);
if (chatFull != null) {
if (chatFull instanceof TLRPC.TL_chatFull) {
chatFull.flags &= -32769;
} else {
chatFull.flags &= -67108865;
}
chatFull.groupcall_default_join_as = null;
JoinCallAlert.resetCache();
}
hangUp(2);
return;
}
if ("GROUPCALL_SSRC_DUPLICATE_MUCH".equals(tL_error.text)) {
createGroupInstance(1, false);
} else if ("GROUPCALL_INVALID".equals(tL_error.text)) {
MessagesController.getInstance(this.currentAccount).loadFullChat(this.chat.id, 0, true);
}
}
private void startGroupCheckShortpoll() {
ChatObject.Call call;
TLRPC.GroupCall groupCall;
if (this.shortPollRunnable != null || sharedInstance == null || (call = this.groupCall) == null) {
return;
}
int[] iArr = this.mySource;
if (iArr[0] == 0 && iArr[1] == 0 && ((groupCall = call.call) == null || !groupCall.rtmp_stream)) {
return;
}
Runnable runnable = new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$startGroupCheckShortpoll$35();
}
};
this.shortPollRunnable = runnable;
AndroidUtilities.runOnUIThread(runnable, 4000L);
}
public void lambda$startGroupCheckShortpoll$35() {
ChatObject.Call call;
TLRPC.GroupCall groupCall;
if (this.shortPollRunnable == null || sharedInstance == null || (call = this.groupCall) == null) {
return;
}
int[] iArr = this.mySource;
int i = 0;
if (iArr[0] == 0 && iArr[1] == 0 && ((groupCall = call.call) == null || !groupCall.rtmp_stream)) {
return;
}
final TLRPC.TL_phone_checkGroupCall tL_phone_checkGroupCall = new TLRPC.TL_phone_checkGroupCall();
tL_phone_checkGroupCall.call = this.groupCall.getInputGroupCall();
while (true) {
int[] iArr2 = this.mySource;
if (i < iArr2.length) {
if (iArr2[i] != 0) {
tL_phone_checkGroupCall.sources.add(Integer.valueOf(iArr2[i]));
}
i++;
} else {
this.checkRequestId = ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_phone_checkGroupCall, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.this.lambda$startGroupCheckShortpoll$34(tL_phone_checkGroupCall, tLObject, tL_error);
}
});
return;
}
}
}
public void lambda$startGroupCheckShortpoll$34(final TLRPC.TL_phone_checkGroupCall tL_phone_checkGroupCall, final TLObject tLObject, final TLRPC.TL_error tL_error) {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$startGroupCheckShortpoll$33(tLObject, tL_phone_checkGroupCall, tL_error);
}
});
}
public void lambda$startGroupCheckShortpoll$33(TLObject tLObject, TLRPC.TL_phone_checkGroupCall tL_phone_checkGroupCall, TLRPC.TL_error tL_error) {
boolean z;
boolean z2;
TLRPC.GroupCall groupCall;
if (this.shortPollRunnable == null || sharedInstance == null || this.groupCall == null) {
return;
}
this.shortPollRunnable = null;
this.checkRequestId = 0;
if (tLObject instanceof TLRPC.Vector) {
TLRPC.Vector vector = (TLRPC.Vector) tLObject;
int[] iArr = this.mySource;
z2 = (iArr[0] == 0 || !tL_phone_checkGroupCall.sources.contains(Integer.valueOf(iArr[0])) || vector.objects.contains(Integer.valueOf(this.mySource[0]))) ? false : true;
int[] iArr2 = this.mySource;
z = (iArr2[1] == 0 || !tL_phone_checkGroupCall.sources.contains(Integer.valueOf(iArr2[1])) || vector.objects.contains(Integer.valueOf(this.mySource[1]))) ? false : true;
} else if (tL_error == null || tL_error.code != 400) {
z = false;
z2 = false;
} else {
int[] iArr3 = this.mySource;
z = iArr3[1] != 0 && tL_phone_checkGroupCall.sources.contains(Integer.valueOf(iArr3[1]));
z2 = true;
}
if (z2) {
createGroupInstance(0, false);
}
if (z) {
createGroupInstance(1, false);
}
int[] iArr4 = this.mySource;
if (iArr4[1] == 0 && iArr4[0] == 0 && ((groupCall = this.groupCall.call) == null || !groupCall.rtmp_stream)) {
return;
}
startGroupCheckShortpoll();
}
private void cancelGroupCheckShortPoll() {
int[] iArr = this.mySource;
if (iArr[1] == 0 && iArr[0] == 0) {
if (this.checkRequestId != 0) {
ConnectionsManager.getInstance(this.currentAccount).cancelRequest(this.checkRequestId, false);
this.checkRequestId = 0;
}
Runnable runnable = this.shortPollRunnable;
if (runnable != null) {
AndroidUtilities.cancelRunOnUIThread(runnable);
this.shortPollRunnable = null;
}
}
}
public static class RequestedParticipant {
public int audioSsrc;
public TLRPC.TL_groupCallParticipant participant;
public RequestedParticipant(TLRPC.TL_groupCallParticipant p, int ssrc) {
this.participant = p;
this.audioSsrc = ssrc;
}
}
private void broadcastUnknownParticipants(long taskPtr, int[] unknown) {
if (this.groupCall == null || this.tgVoip[0] == null) {
return;
}
long selfId = getSelfId();
ArrayList arrayList = null;
int length = unknown.length;
for (int i = 0; i < length; i++) {
TLRPC.TL_groupCallParticipant tL_groupCallParticipant = this.groupCall.participantsBySources.get(unknown[i]);
if (tL_groupCallParticipant == null && (tL_groupCallParticipant = this.groupCall.participantsByVideoSources.get(unknown[i])) == null) {
tL_groupCallParticipant = this.groupCall.participantsByPresentationSources.get(unknown[i]);
}
if (tL_groupCallParticipant != null && MessageObject.getPeerId(tL_groupCallParticipant.peer) != selfId && tL_groupCallParticipant.source != 0) {
if (arrayList == null) {
arrayList = new ArrayList();
}
arrayList.add(new RequestedParticipant(tL_groupCallParticipant, unknown[i]));
}
}
if (arrayList != null) {
int[] iArr = new int[arrayList.size()];
int size = arrayList.size();
for (int i2 = 0; i2 < size; i2++) {
iArr[i2] = ((RequestedParticipant) arrayList.get(i2)).audioSsrc;
}
this.tgVoip[0].onMediaDescriptionAvailable(taskPtr, iArr);
int size2 = arrayList.size();
for (int i3 = 0; i3 < size2; i3++) {
RequestedParticipant requestedParticipant = (RequestedParticipant) arrayList.get(i3);
TLRPC.TL_groupCallParticipant tL_groupCallParticipant2 = requestedParticipant.participant;
if (tL_groupCallParticipant2.muted_by_you) {
this.tgVoip[0].setVolume(requestedParticipant.audioSsrc, 0.0d);
} else {
NativeInstance nativeInstance = this.tgVoip[0];
int i4 = requestedParticipant.audioSsrc;
double participantVolume = ChatObject.getParticipantVolume(tL_groupCallParticipant2);
Double.isNaN(participantVolume);
nativeInstance.setVolume(i4, participantVolume / 10000.0d);
}
}
}
}
private void createGroupInstance(final int type, boolean switchAccount) {
boolean z;
String logFilePath;
if (switchAccount) {
this.mySource[type] = 0;
if (type == 0) {
this.switchingAccount = switchAccount;
}
}
cancelGroupCheckShortPoll();
if (type == 0) {
this.wasConnected = false;
} else if (!this.wasConnected) {
this.reconnectScreenCapture = true;
return;
}
if (this.tgVoip[type] == null) {
if (BuildVars.DEBUG_VERSION) {
logFilePath = VoIPHelper.getLogFilePath("voip_" + type + "_" + this.groupCall.call.id);
} else {
logFilePath = VoIPHelper.getLogFilePath(this.groupCall.call.id, false);
}
this.tgVoip[type] = NativeInstance.makeGroup(logFilePath, this.captureDevice[type], type == 1, type == 0 && SharedConfig.noiseSupression, new NativeInstance.PayloadCallback() {
@Override
public final void run(int i, String str) {
VoIPService.this.lambda$createGroupInstance$36(type, i, str);
}
}, new NativeInstance.AudioLevelsCallback() {
@Override
public final void run(int[] iArr, float[] fArr, boolean[] zArr) {
VoIPService.this.lambda$createGroupInstance$38(type, iArr, fArr, zArr);
}
}, new NativeInstance.VideoSourcesCallback() {
@Override
public final void run(long j, int[] iArr) {
VoIPService.this.lambda$createGroupInstance$40(type, j, iArr);
}
}, new NativeInstance.RequestBroadcastPartCallback() {
@Override
public final void run(long j, long j2, int i, int i2) {
VoIPService.this.lambda$createGroupInstance$45(type, j, j2, i, i2);
}
}, new NativeInstance.RequestBroadcastPartCallback() {
@Override
public final void run(long j, long j2, int i, int i2) {
VoIPService.this.lambda$createGroupInstance$47(type, j, j2, i, i2);
}
}, new NativeInstance.RequestCurrentTimeCallback() {
@Override
public final void run(long j) {
VoIPService.this.lambda$createGroupInstance$49(type, j);
}
});
this.tgVoip[type].setOnStateUpdatedListener(new Instance.OnStateUpdatedListener() {
@Override
public final void onStateUpdated(int i, boolean z2) {
VoIPService.this.lambda$createGroupInstance$50(type, i, z2);
}
});
z = true;
} else {
z = false;
}
this.tgVoip[type].resetGroupInstance(!z, false);
if (this.captureDevice[type] != 0) {
this.destroyCaptureDevice[type] = false;
}
if (type == 0) {
dispatchStateChanged(1);
}
}
public void lambda$createGroupInstance$36(int i, int i2, String str) {
if (i == 0) {
startGroupCall(i2, str, true);
} else {
startScreenCapture(i2, str);
}
}
public void lambda$createGroupInstance$38(int i, int[] iArr, float[] fArr, boolean[] zArr) {
ChatObject.Call call;
if (sharedInstance == null || (call = this.groupCall) == null || i != 0) {
return;
}
call.processVoiceLevelsUpdate(iArr, fArr, zArr);
float f = 0.0f;
boolean z = false;
for (int i2 = 0; i2 < iArr.length; i2++) {
if (iArr[i2] == 0) {
if (this.lastTypingTimeSend < SystemClock.uptimeMillis() - 5000 && fArr[i2] > 0.1f && zArr[i2]) {
this.lastTypingTimeSend = SystemClock.uptimeMillis();
TLRPC.TL_messages_setTyping tL_messages_setTyping = new TLRPC.TL_messages_setTyping();
tL_messages_setTyping.action = new TLRPC.TL_speakingInGroupCallAction();
tL_messages_setTyping.peer = MessagesController.getInputPeer(this.chat);
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_messages_setTyping, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.lambda$createGroupInstance$37(tLObject, tL_error);
}
});
}
NotificationCenter.getGlobalInstance().lambda$postNotificationNameOnUIThread$1(NotificationCenter.webRtcMicAmplitudeEvent, Float.valueOf(fArr[i2]));
} else {
f = Math.max(f, fArr[i2]);
z = true;
}
}
if (z) {
NotificationCenter.getGlobalInstance().lambda$postNotificationNameOnUIThread$1(NotificationCenter.webRtcSpeakerAmplitudeEvent, Float.valueOf(f));
NativeInstance.AudioLevelsCallback audioLevelsCallback2 = audioLevelsCallback;
if (audioLevelsCallback2 != null) {
audioLevelsCallback2.run(iArr, fArr, zArr);
}
}
}
public void lambda$createGroupInstance$40(int i, final long j, final int[] iArr) {
ChatObject.Call call;
if (sharedInstance == null || (call = this.groupCall) == null || i != 0) {
return;
}
call.processUnknownVideoParticipants(iArr, new ChatObject.Call.OnParticipantsLoad() {
@Override
public final void onLoad(ArrayList arrayList) {
VoIPService.this.lambda$createGroupInstance$39(j, iArr, arrayList);
}
});
}
public void lambda$createGroupInstance$39(long j, int[] iArr, ArrayList arrayList) {
if (sharedInstance == null || this.groupCall == null) {
return;
}
broadcastUnknownParticipants(j, iArr);
}
public void lambda$createGroupInstance$45(final int i, final long j, long j2, final int i2, final int i3) {
StringBuilder sb;
if (i != 0) {
return;
}
TLRPC.TL_upload_getFile tL_upload_getFile = new TLRPC.TL_upload_getFile();
tL_upload_getFile.limit = 131072;
TLRPC.TL_inputGroupCallStream tL_inputGroupCallStream = new TLRPC.TL_inputGroupCallStream();
tL_inputGroupCallStream.call = this.groupCall.getInputGroupCall();
tL_inputGroupCallStream.time_ms = j;
if (j2 == 500) {
tL_inputGroupCallStream.scale = 1;
}
if (i2 != 0) {
tL_inputGroupCallStream.flags |= 1;
tL_inputGroupCallStream.video_channel = i2;
tL_inputGroupCallStream.video_quality = i3;
}
tL_upload_getFile.location = tL_inputGroupCallStream;
if (i2 == 0) {
sb = new StringBuilder();
sb.append(BuildConfig.APP_CENTER_HASH);
sb.append(j);
} else {
sb = new StringBuilder();
sb.append(i2);
sb.append("_");
sb.append(j);
sb.append("_");
sb.append(i3);
}
final String sb2 = sb.toString();
final int sendRequest = AccountInstance.getInstance(this.currentAccount).getConnectionsManager().sendRequest(tL_upload_getFile, new RequestDelegateTimestamp() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error, long j3) {
VoIPService.this.lambda$createGroupInstance$43(sb2, i, j, i2, i3, tLObject, tL_error, j3);
}
}, 2, 2, this.groupCall.call.stream_dc_id);
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$createGroupInstance$44(sb2, sendRequest);
}
});
}
public void lambda$createGroupInstance$41(String str) {
this.currentStreamRequestTimestamp.remove(str);
}
public void lambda$createGroupInstance$43(final String str, final int i, long j, int i2, int i3, TLObject tLObject, TLRPC.TL_error tL_error, long j2) {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$createGroupInstance$41(str);
}
});
NativeInstance[] nativeInstanceArr = this.tgVoip;
if (nativeInstanceArr[i] == null) {
return;
}
if (tLObject != null) {
NativeInstance nativeInstance = nativeInstanceArr[i];
NativeByteBuffer nativeByteBuffer = ((TLRPC.TL_upload_file) tLObject).bytes;
nativeInstance.onStreamPartAvailable(j, nativeByteBuffer.buffer, nativeByteBuffer.limit(), j2, i2, i3);
} else if ("GROUPCALL_JOIN_MISSING".equals(tL_error.text)) {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$createGroupInstance$42(i);
}
});
} else {
this.tgVoip[i].onStreamPartAvailable(j, null, ("TIME_TOO_BIG".equals(tL_error.text) || tL_error.text.startsWith("FLOOD_WAIT")) ? 0 : -1, j2, i2, i3);
}
}
public void lambda$createGroupInstance$42(int i) {
createGroupInstance(i, false);
}
public void lambda$createGroupInstance$44(String str, int i) {
this.currentStreamRequestTimestamp.put(str, Integer.valueOf(i));
}
public void lambda$createGroupInstance$47(int i, final long j, long j2, final int i2, final int i3) {
if (i != 0) {
return;
}
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$createGroupInstance$46(i2, j, i3);
}
});
}
public void lambda$createGroupInstance$46(int i, long j, int i2) {
String str;
if (i == 0) {
str = BuildConfig.APP_CENTER_HASH + j;
} else {
str = i + "_" + j + "_" + i2;
}
Integer num = this.currentStreamRequestTimestamp.get(str);
if (num != null) {
AccountInstance.getInstance(this.currentAccount).getConnectionsManager().cancelRequest(num.intValue(), true);
this.currentStreamRequestTimestamp.remove(str);
}
}
public void lambda$createGroupInstance$49(final int i, final long j) {
TLRPC.GroupCall groupCall;
ChatObject.Call call = this.groupCall;
if (call != null && (groupCall = call.call) != null && groupCall.rtmp_stream) {
TLRPC.TL_phone_getGroupCallStreamChannels tL_phone_getGroupCallStreamChannels = new TLRPC.TL_phone_getGroupCallStreamChannels();
tL_phone_getGroupCallStreamChannels.call = this.groupCall.getInputGroupCall();
ChatObject.Call call2 = this.groupCall;
if (call2 == null || call2.call == null || this.tgVoip[i] == null) {
NativeInstance[] nativeInstanceArr = this.tgVoip;
if (nativeInstanceArr[i] != null) {
nativeInstanceArr[i].onRequestTimeComplete(j, 0L);
return;
}
return;
}
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_phone_getGroupCallStreamChannels, new RequestDelegateTimestamp() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error, long j2) {
VoIPService.this.lambda$createGroupInstance$48(i, j, tLObject, tL_error, j2);
}
}, 2, 2, this.groupCall.call.stream_dc_id);
return;
}
NativeInstance[] nativeInstanceArr2 = this.tgVoip;
if (nativeInstanceArr2[i] != null) {
nativeInstanceArr2[i].onRequestTimeComplete(j, ConnectionsManager.getInstance(this.currentAccount).getCurrentTimeMillis());
}
}
public void lambda$createGroupInstance$48(int i, long j, TLObject tLObject, TLRPC.TL_error tL_error, long j2) {
if (tL_error == null) {
TLRPC.TL_phone_groupCallStreamChannels tL_phone_groupCallStreamChannels = (TLRPC.TL_phone_groupCallStreamChannels) tLObject;
r7 = tL_phone_groupCallStreamChannels.channels.isEmpty() ? 0L : tL_phone_groupCallStreamChannels.channels.get(0).last_timestamp_ms;
ChatObject.Call call = this.groupCall;
if (!call.loadedRtmpStreamParticipant) {
call.createRtmpStreamParticipant(tL_phone_groupCallStreamChannels.channels);
this.groupCall.loadedRtmpStreamParticipant = true;
}
}
NativeInstance[] nativeInstanceArr = this.tgVoip;
if (nativeInstanceArr[i] != null) {
nativeInstanceArr[i].onRequestTimeComplete(j, r7);
}
}
public void lambda$createGroupInstance$50(final int type, int state, boolean inTransition) {
if (type != 0) {
return;
}
dispatchStateChanged((state == 1 || this.switchingStream) ? 3 : 5);
if (this.switchingStream && (state == 0 || (state == 1 && inTransition))) {
Runnable runnable = new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$updateConnectionState$51(type);
}
};
this.switchingStreamTimeoutRunnable = runnable;
AndroidUtilities.runOnUIThread(runnable, 3000L);
}
if (state == 0) {
startGroupCheckShortpoll();
if (!this.playedConnectedSound || this.spPlayId != 0 || this.switchingStream || this.switchingAccount) {
return;
}
Utilities.globalQueue.postRunnable(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$updateConnectionState$52();
}
});
return;
}
cancelGroupCheckShortPoll();
if (!inTransition) {
this.switchingStream = false;
this.switchingAccount = false;
}
Runnable runnable2 = this.switchingStreamTimeoutRunnable;
if (runnable2 != null) {
AndroidUtilities.cancelRunOnUIThread(runnable2);
this.switchingStreamTimeoutRunnable = null;
}
if (this.playedConnectedSound) {
Utilities.globalQueue.postRunnable(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$updateConnectionState$53();
}
});
Runnable runnable3 = this.connectingSoundRunnable;
if (runnable3 != null) {
AndroidUtilities.cancelRunOnUIThread(runnable3);
this.connectingSoundRunnable = null;
}
} else {
playConnectedSound();
}
if (this.wasConnected) {
return;
}
this.wasConnected = true;
if (this.reconnectScreenCapture) {
createGroupInstance(1, false);
this.reconnectScreenCapture = false;
}
NativeInstance nativeInstance = this.tgVoip[0];
if (nativeInstance != null && !this.micMute) {
nativeInstance.setMuteMicrophone(false);
}
setParticipantsVolume();
}
public void lambda$updateConnectionState$51(int i) {
if (this.switchingStreamTimeoutRunnable == null) {
return;
}
this.switchingStream = false;
lambda$createGroupInstance$50(i, 0, true);
this.switchingStreamTimeoutRunnable = null;
}
public void lambda$updateConnectionState$52() {
int i = this.spPlayId;
if (i != 0) {
this.soundPool.stop(i);
}
this.spPlayId = this.soundPool.play(this.spVoiceChatConnecting, 1.0f, 1.0f, 0, -1, 1.0f);
}
public void lambda$updateConnectionState$53() {
int i = this.spPlayId;
if (i != 0) {
this.soundPool.stop(i);
this.spPlayId = 0;
}
}
public void setParticipantsVolume() {
if (this.tgVoip[0] != null) {
int size = this.groupCall.participants.size();
for (int i = 0; i < size; i++) {
TLRPC.TL_groupCallParticipant tL_groupCallParticipant = (TLRPC.TL_groupCallParticipant) this.groupCall.participants.valueAt(i);
if (!tL_groupCallParticipant.self && tL_groupCallParticipant.source != 0 && (tL_groupCallParticipant.can_self_unmute || !tL_groupCallParticipant.muted)) {
if (tL_groupCallParticipant.muted_by_you) {
setParticipantVolume(tL_groupCallParticipant, 0);
} else {
setParticipantVolume(tL_groupCallParticipant, ChatObject.getParticipantVolume(tL_groupCallParticipant));
}
}
}
}
}
public void setParticipantVolume(TLRPC.TL_groupCallParticipant participant, int volume) {
int i;
NativeInstance nativeInstance = this.tgVoip[0];
int i2 = participant.source;
double d = volume;
Double.isNaN(d);
double d2 = d / 10000.0d;
nativeInstance.setVolume(i2, d2);
TLRPC.TL_groupCallParticipantVideo tL_groupCallParticipantVideo = participant.presentation;
if (tL_groupCallParticipantVideo == null || (i = tL_groupCallParticipantVideo.audio_source) == 0) {
return;
}
this.tgVoip[0].setVolume(i, d2);
}
public boolean isSwitchingStream() {
return this.switchingStream;
}
private void initiateActualEncryptedCall() {
throw new UnsupportedOperationException("Method not decompiled: org.telegram.messenger.voip.VoIPService.initiateActualEncryptedCall():void");
}
public void lambda$initiateActualEncryptedCall$54() {
Toast.makeText(this, "This call uses TCP which will degrade its quality.", 0).show();
}
public void lambda$initiateActualEncryptedCall$55(int[] iArr, float[] fArr, boolean[] zArr) {
if (sharedInstance == null || this.privateCall == null) {
return;
}
NotificationCenter.getGlobalInstance().lambda$postNotificationNameOnUIThread$1(NotificationCenter.webRtcMicAmplitudeEvent, Float.valueOf(fArr[0]));
NotificationCenter.getGlobalInstance().lambda$postNotificationNameOnUIThread$1(NotificationCenter.webRtcSpeakerAmplitudeEvent, Float.valueOf(fArr[1]));
}
public void lambda$initiateActualEncryptedCall$57(final int i, final int i2) {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$initiateActualEncryptedCall$56(i, i2);
}
});
}
public void lambda$initiateActualEncryptedCall$56(int i, int i2) {
this.remoteAudioState = i;
this.remoteVideoState = i2;
checkIsNear();
for (int i3 = 0; i3 < this.stateListeners.size(); i3++) {
this.stateListeners.get(i3).onMediaStateUpdated(i, i2);
}
}
public void lambda$playConnectedSound$58() {
this.soundPool.play(this.spVoiceChatStartId, 1.0f, 1.0f, 0, 0, 1.0f);
}
public void playConnectedSound() {
Utilities.globalQueue.postRunnable(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$playConnectedSound$58();
}
});
this.playedConnectedSound = true;
}
private void startConnectingSound() {
Utilities.globalQueue.postRunnable(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$startConnectingSound$59();
}
});
}
public void lambda$startConnectingSound$59() {
int i = this.spPlayId;
if (i != 0) {
this.soundPool.stop(i);
}
int play = this.soundPool.play(this.spConnectingId, 1.0f, 1.0f, 0, -1, 1.0f);
this.spPlayId = play;
if (play == 0) {
AnonymousClass7 anonymousClass7 = new AnonymousClass7();
this.connectingSoundRunnable = anonymousClass7;
AndroidUtilities.runOnUIThread(anonymousClass7, 100L);
}
}
public class AnonymousClass7 implements Runnable {
public AnonymousClass7() {
}
@Override
public void run() {
if (VoIPService.sharedInstance == null) {
return;
}
Utilities.globalQueue.postRunnable(new Runnable() {
@Override
public final void run() {
VoIPService.AnonymousClass7.this.lambda$run$0();
}
});
}
public void lambda$run$0() {
if (VoIPService.this.spPlayId == 0) {
VoIPService voIPService = VoIPService.this;
voIPService.spPlayId = voIPService.soundPool.play(VoIPService.this.spConnectingId, 1.0f, 1.0f, 0, -1, 1.0f);
}
if (VoIPService.this.spPlayId == 0) {
AndroidUtilities.runOnUIThread(this, 100L);
} else {
VoIPService.this.connectingSoundRunnable = null;
}
}
}
public void onSignalingData(byte[] data) {
if (this.privateCall == null) {
return;
}
TLRPC.TL_phone_sendSignalingData tL_phone_sendSignalingData = new TLRPC.TL_phone_sendSignalingData();
TLRPC.TL_inputPhoneCall tL_inputPhoneCall = new TLRPC.TL_inputPhoneCall();
tL_phone_sendSignalingData.peer = tL_inputPhoneCall;
TLRPC.PhoneCall phoneCall = this.privateCall;
tL_inputPhoneCall.access_hash = phoneCall.access_hash;
tL_inputPhoneCall.id = phoneCall.id;
tL_phone_sendSignalingData.data = data;
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_phone_sendSignalingData, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.lambda$onSignalingData$60(tLObject, tL_error);
}
});
}
public boolean isVideoAvailable() {
return this.isVideoAvailable;
}
public void onMediaButtonEvent(KeyEvent ev) {
if (ev == null) {
return;
}
if ((ev.getKeyCode() == 79 || ev.getKeyCode() == 127 || ev.getKeyCode() == 85) && ev.getAction() == 1) {
if (this.currentState == 15) {
acceptIncomingCall();
} else {
setMicMute(!isMicMute(), false, true);
}
}
}
public byte[] getGA() {
return this.g_a;
}
public void forceRating() {
this.forceRating = true;
}
private String[] getEmoji() {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
try {
byteArrayOutputStream.write(this.authKey);
byteArrayOutputStream.write(this.g_a);
} catch (IOException unused) {
}
return EncryptionKeyEmojifier.emojifyForCall(Utilities.computeSHA256(byteArrayOutputStream.toByteArray(), 0, byteArrayOutputStream.size()));
}
public boolean hasEarpiece() {
CallConnection callConnection;
if (USE_CONNECTION_SERVICE && (callConnection = this.systemCallConnection) != null && callConnection.getCallAudioState() != null) {
return (this.systemCallConnection.getCallAudioState().getSupportedRouteMask() & 5) != 0;
}
if (((TelephonyManager) getSystemService("phone")).getPhoneType() != 0) {
return true;
}
Boolean bool = this.mHasEarpiece;
if (bool != null) {
return bool.booleanValue();
}
try {
AudioManager audioManager = (AudioManager) getSystemService("audio");
Method method = AudioManager.class.getMethod("getDevicesForStream", Integer.TYPE);
int i = AudioManager.class.getField("DEVICE_OUT_EARPIECE").getInt(null);
if ((((Integer) method.invoke(audioManager, 0)).intValue() & i) == i) {
this.mHasEarpiece = Boolean.TRUE;
} else {
this.mHasEarpiece = Boolean.FALSE;
}
} catch (Throwable th) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("Error while checking earpiece! ", th);
}
this.mHasEarpiece = Boolean.TRUE;
}
return this.mHasEarpiece.booleanValue();
}
public int getStatsNetworkType() {
NetworkInfo networkInfo = this.lastNetInfo;
if (networkInfo == null || networkInfo.getType() != 0) {
return 1;
}
return this.lastNetInfo.isRoaming() ? 2 : 0;
}
public void setSwitchingCamera(boolean switching, boolean isFrontFace) {
this.switchingCamera = switching;
if (switching) {
return;
}
this.isFrontFaceCamera = isFrontFace;
for (int i = 0; i < this.stateListeners.size(); i++) {
this.stateListeners.get(i).onCameraSwitch(this.isFrontFaceCamera);
}
}
public void onCameraFirstFrameAvailable() {
for (int i = 0; i < this.stateListeners.size(); i++) {
this.stateListeners.get(i).onCameraFirstFrameAvailable();
}
}
public void registerStateListener(StateListener l) {
if (this.stateListeners.contains(l)) {
return;
}
this.stateListeners.add(l);
int i = this.currentState;
if (i != 0) {
l.onStateChanged(i);
}
int i2 = this.signalBarCount;
if (i2 != 0) {
l.onSignalBarsCountChanged(i2);
}
}
public void unregisterStateListener(StateListener l) {
this.stateListeners.remove(l);
}
public void editCallMember(TLObject object, Boolean mute, Boolean muteVideo, Integer volume, Boolean raiseHand, final Runnable onComplete) {
TLRPC.InputPeer inputPeer;
if (object == null || this.groupCall == null) {
return;
}
TLRPC.TL_phone_editGroupCallParticipant tL_phone_editGroupCallParticipant = new TLRPC.TL_phone_editGroupCallParticipant();
tL_phone_editGroupCallParticipant.call = this.groupCall.getInputGroupCall();
if (object instanceof TLRPC.User) {
TLRPC.User user = (TLRPC.User) object;
if (UserObject.isUserSelf(user) && (inputPeer = this.groupCallPeer) != null) {
tL_phone_editGroupCallParticipant.participant = inputPeer;
} else {
tL_phone_editGroupCallParticipant.participant = MessagesController.getInputPeer(user);
if (BuildVars.LOGS_ENABLED) {
FileLog.d("edit group call part id = " + tL_phone_editGroupCallParticipant.participant.user_id + " access_hash = " + tL_phone_editGroupCallParticipant.participant.user_id);
}
}
} else if (object instanceof TLRPC.Chat) {
tL_phone_editGroupCallParticipant.participant = MessagesController.getInputPeer((TLRPC.Chat) object);
if (BuildVars.LOGS_ENABLED) {
StringBuilder sb = new StringBuilder();
sb.append("edit group call part id = ");
TLRPC.InputPeer inputPeer2 = tL_phone_editGroupCallParticipant.participant;
long j = inputPeer2.chat_id;
if (j == 0) {
j = inputPeer2.channel_id;
}
sb.append(j);
sb.append(" access_hash = ");
sb.append(tL_phone_editGroupCallParticipant.participant.access_hash);
FileLog.d(sb.toString());
}
}
if (mute != null) {
tL_phone_editGroupCallParticipant.muted = mute.booleanValue();
tL_phone_editGroupCallParticipant.flags |= 1;
}
if (volume != null) {
tL_phone_editGroupCallParticipant.volume = volume.intValue();
tL_phone_editGroupCallParticipant.flags |= 2;
}
if (raiseHand != null) {
tL_phone_editGroupCallParticipant.raise_hand = raiseHand.booleanValue();
tL_phone_editGroupCallParticipant.flags |= 4;
}
if (muteVideo != null) {
tL_phone_editGroupCallParticipant.video_stopped = muteVideo.booleanValue();
tL_phone_editGroupCallParticipant.flags |= 8;
}
if (BuildVars.LOGS_ENABLED) {
FileLog.d("edit group call flags = " + tL_phone_editGroupCallParticipant.flags);
}
final int i = this.currentAccount;
AccountInstance.getInstance(i).getConnectionsManager().sendRequest(tL_phone_editGroupCallParticipant, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.this.lambda$editCallMember$61(i, onComplete, tLObject, tL_error);
}
});
}
public void lambda$editCallMember$61(int i, Runnable runnable, TLObject tLObject, TLRPC.TL_error tL_error) {
if (tLObject != null) {
AccountInstance.getInstance(i).getMessagesController().processUpdates((TLRPC.Updates) tLObject, false);
} else if (tL_error != null && "GROUPCALL_VIDEO_TOO_MUCH".equals(tL_error.text)) {
this.groupCall.reloadGroupCall();
}
if (runnable != null) {
AndroidUtilities.runOnUIThread(runnable);
}
}
public boolean isMicMute() {
return this.micMute;
}
public void toggleSpeakerphoneOrShowRouteSheet(Context context, boolean fromOverlayWindow) {
toggleSpeakerphoneOrShowRouteSheet(context, fromOverlayWindow, null);
}
public void switchToSpeaker() {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$switchToSpeaker$63();
}
}, 500L);
}
public void lambda$switchToSpeaker$63() {
VoipAudioManager voipAudioManager = VoipAudioManager.get();
if ((isBluetoothHeadsetConnected() && hasEarpiece()) || this.isHeadsetPlugged || isSpeakerphoneOn()) {
return;
}
voipAudioManager.setSpeakerphoneOn(true);
voipAudioManager.isBluetoothAndSpeakerOnAsync(new Utilities.Callback2() {
@Override
public final void run(Object obj, Object obj2) {
VoIPService.this.lambda$switchToSpeaker$62((Boolean) obj, (Boolean) obj2);
}
});
}
public void lambda$switchToSpeaker$62(Boolean bool, Boolean bool2) {
updateOutputGainControlState();
Iterator<StateListener> it = this.stateListeners.iterator();
while (it.hasNext()) {
it.next().onAudioSettingsChanged();
}
}
public void toggleSpeakerphoneOrShowRouteSheet(Context context, boolean fromOverlayWindow, final Integer selectedPos) {
CallConnection callConnection;
int i;
String str;
if (isBluetoothHeadsetConnected() && hasEarpiece()) {
BottomSheet.Builder cellType = new BottomSheet.Builder(context).setTitle(LocaleController.getString("VoipOutputDevices", R.string.VoipOutputDevices), true).selectedPos(selectedPos).setCellType(selectedPos != null ? BottomSheet.Builder.CELL_TYPE_CALL : 0);
CharSequence[] charSequenceArr = new CharSequence[3];
charSequenceArr[0] = LocaleController.getString("VoipAudioRoutingSpeaker", R.string.VoipAudioRoutingSpeaker);
if (this.isHeadsetPlugged) {
i = R.string.VoipAudioRoutingHeadset;
str = "VoipAudioRoutingHeadset";
} else {
i = R.string.VoipAudioRoutingEarpiece;
str = "VoipAudioRoutingEarpiece";
}
charSequenceArr[1] = LocaleController.getString(str, i);
String str2 = this.currentBluetoothDeviceName;
if (str2 == null) {
str2 = LocaleController.getString("VoipAudioRoutingBluetooth", R.string.VoipAudioRoutingBluetooth);
}
charSequenceArr[2] = str2;
int[] iArr = new int[3];
iArr[0] = R.drawable.msg_call_speaker;
iArr[1] = this.isHeadsetPlugged ? R.drawable.calls_menu_headset : R.drawable.msg_call_earpiece;
iArr[2] = R.drawable.msg_call_bluetooth;
BottomSheet.Builder items = cellType.setItems(charSequenceArr, iArr, new DialogInterface.OnClickListener() {
@Override
public final void onClick(DialogInterface dialogInterface, int i2) {
VoIPService.this.lambda$toggleSpeakerphoneOrShowRouteSheet$64(dialogInterface, i2);
}
});
final BottomSheet create = items.create();
create.setOnShowListener(new DialogInterface.OnShowListener() {
@Override
public final void onShow(DialogInterface dialogInterface) {
VoIPService.lambda$toggleSpeakerphoneOrShowRouteSheet$65(create, selectedPos, dialogInterface);
}
});
if (fromOverlayWindow) {
if (Build.VERSION.SDK_INT >= 26) {
create.getWindow().setType(2038);
} else {
create.getWindow().setType(2003);
}
}
items.show();
return;
}
boolean z = USE_CONNECTION_SERVICE;
if (z && (callConnection = this.systemCallConnection) != null && callConnection.getCallAudioState() != null) {
if (hasEarpiece()) {
CallConnection callConnection2 = this.systemCallConnection;
callConnection2.setAudioRoute(callConnection2.getCallAudioState().getRoute() != 8 ? 8 : 5);
} else {
CallConnection callConnection3 = this.systemCallConnection;
callConnection3.setAudioRoute(callConnection3.getCallAudioState().getRoute() == 2 ? 5 : 2);
}
} else {
if (this.audioConfigured && !z) {
AudioManager audioManager = (AudioManager) getSystemService("audio");
VoipAudioManager voipAudioManager = VoipAudioManager.get();
if (hasEarpiece()) {
voipAudioManager.setSpeakerphoneOn(!voipAudioManager.isSpeakerphoneOn());
} else {
audioManager.setBluetoothScoOn(!audioManager.isBluetoothScoOn());
}
voipAudioManager.isBluetoothAndSpeakerOnAsync(new Utilities.Callback2() {
@Override
public final void run(Object obj, Object obj2) {
VoIPService.this.lambda$toggleSpeakerphoneOrShowRouteSheet$66((Boolean) obj, (Boolean) obj2);
}
});
return;
}
this.speakerphoneStateToSet = !this.speakerphoneStateToSet;
}
Iterator<StateListener> it = this.stateListeners.iterator();
while (it.hasNext()) {
it.next().onAudioSettingsChanged();
}
}
public void lambda$toggleSpeakerphoneOrShowRouteSheet$64(DialogInterface dialogInterface, int i) {
if (getSharedInstance() == null) {
return;
}
setAudioOutput(i);
}
public static void lambda$toggleSpeakerphoneOrShowRouteSheet$65(BottomSheet bottomSheet, Integer num, DialogInterface dialogInterface) {
for (int i = 0; i < bottomSheet.getItemViews().size(); i++) {
int i2 = Theme.key_dialogTextBlack;
bottomSheet.setItemColor(i, Theme.getColor(i2), Theme.getColor(i2));
}
if (num != null) {
int color = Theme.getColor(Theme.key_dialogTextLink);
bottomSheet.setItemColor(num.intValue(), color, color);
}
}
public void lambda$toggleSpeakerphoneOrShowRouteSheet$66(Boolean bool, Boolean bool2) {
updateOutputGainControlState();
Iterator<StateListener> it = this.stateListeners.iterator();
while (it.hasNext()) {
it.next().onAudioSettingsChanged();
}
}
public void setAudioOutput(int which) {
CallConnection callConnection;
if (BuildVars.LOGS_ENABLED) {
FileLog.d("setAudioOutput " + which);
}
AudioManager audioManager = (AudioManager) getSystemService("audio");
VoipAudioManager voipAudioManager = VoipAudioManager.get();
boolean z = USE_CONNECTION_SERVICE;
if (!z || (callConnection = this.systemCallConnection) == null) {
if (this.audioConfigured && !z) {
if (which == 0) {
this.needSwitchToBluetoothAfterScoActivates = false;
if (this.bluetoothScoActive || this.bluetoothScoConnecting) {
audioManager.stopBluetoothSco();
this.bluetoothScoActive = false;
this.bluetoothScoConnecting = false;
}
audioManager.setBluetoothScoOn(false);
voipAudioManager.setSpeakerphoneOn(true);
this.audioRouteToSet = 1;
} else if (which == 1) {
this.needSwitchToBluetoothAfterScoActivates = false;
if (this.bluetoothScoActive || this.bluetoothScoConnecting) {
audioManager.stopBluetoothSco();
this.bluetoothScoActive = false;
this.bluetoothScoConnecting = false;
}
voipAudioManager.setSpeakerphoneOn(false);
audioManager.setBluetoothScoOn(false);
this.audioRouteToSet = 0;
} else if (which == 2) {
if (!this.bluetoothScoActive) {
this.needSwitchToBluetoothAfterScoActivates = true;
try {
audioManager.startBluetoothSco();
} catch (Throwable th) {
FileLog.e(th);
}
} else {
audioManager.setBluetoothScoOn(true);
voipAudioManager.setSpeakerphoneOn(false);
}
this.audioRouteToSet = 2;
}
updateOutputGainControlState();
} else if (which == 0) {
this.audioRouteToSet = 1;
this.speakerphoneStateToSet = true;
} else if (which == 1) {
this.audioRouteToSet = 0;
this.speakerphoneStateToSet = false;
} else if (which == 2) {
this.audioRouteToSet = 2;
this.speakerphoneStateToSet = false;
}
} else if (which == 0) {
callConnection.setAudioRoute(8);
} else if (which == 1) {
callConnection.setAudioRoute(5);
} else if (which == 2) {
callConnection.setAudioRoute(2);
}
Iterator<StateListener> it = this.stateListeners.iterator();
while (it.hasNext()) {
it.next().onAudioSettingsChanged();
}
}
public boolean isSpeakerphoneOn() {
CallConnection callConnection;
boolean z = USE_CONNECTION_SERVICE;
if (z && (callConnection = this.systemCallConnection) != null && callConnection.getCallAudioState() != null) {
int route = this.systemCallConnection.getCallAudioState().getRoute();
if (hasEarpiece()) {
if (route == 8) {
return true;
}
} else if (route == 2) {
return true;
}
return false;
}
if (this.audioConfigured && !z) {
return hasEarpiece() ? VoipAudioManager.get().isSpeakerphoneOn() : ((AudioManager) getSystemService("audio")).isBluetoothScoOn();
}
return this.speakerphoneStateToSet;
}
public int getCurrentAudioRoute() {
if (USE_CONNECTION_SERVICE) {
CallConnection callConnection = this.systemCallConnection;
if (callConnection != null && callConnection.getCallAudioState() != null) {
int route = this.systemCallConnection.getCallAudioState().getRoute();
if (route != 1) {
if (route == 2) {
return 2;
}
if (route != 4) {
if (route == 8) {
return 1;
}
}
}
return 0;
}
return this.audioRouteToSet;
}
if (this.audioConfigured) {
AudioManager audioManager = (AudioManager) getSystemService("audio");
VoipAudioManager voipAudioManager = VoipAudioManager.get();
if (audioManager.isBluetoothScoOn()) {
return 2;
}
return voipAudioManager.isSpeakerphoneOn() ? 1 : 0;
}
return this.audioRouteToSet;
}
public String getDebugString() {
NativeInstance[] nativeInstanceArr = this.tgVoip;
return nativeInstanceArr[0] != null ? nativeInstanceArr[0].getDebugInfo() : BuildConfig.APP_CENTER_HASH;
}
public long getCallDuration() {
if (this.callStartTime == 0) {
return 0L;
}
return SystemClock.elapsedRealtime() - this.callStartTime;
}
public void stopRinging() {
synchronized (sync) {
MediaPlayer mediaPlayer = this.ringtonePlayer;
if (mediaPlayer != null) {
mediaPlayer.stop();
this.ringtonePlayer.release();
this.ringtonePlayer = null;
}
}
Vibrator vibrator = this.vibrator;
if (vibrator != null) {
vibrator.cancel();
this.vibrator = null;
}
}
private void showNotification(String name, Bitmap photo) {
int i;
String str;
int i2;
String str2;
Intent action = new Intent(this, (Class<?>) LaunchActivity.class).setAction(this.groupCall != null ? "voip_chat" : "voip");
if (this.groupCall != null) {
action.putExtra("currentAccount", this.currentAccount);
}
Notification.Builder contentIntent = new Notification.Builder(this).setContentText(name).setContentIntent(PendingIntent.getActivity(this, 50, action, 33554432));
if (this.groupCall != null) {
if (ChatObject.isChannelOrGiga(this.chat)) {
i2 = R.string.VoipLiveStream;
str2 = "VoipLiveStream";
} else {
i2 = R.string.VoipVoiceChat;
str2 = "VoipVoiceChat";
}
contentIntent.setContentTitle(LocaleController.getString(str2, i2));
contentIntent.setSmallIcon(isMicMute() ? R.drawable.voicechat_muted : R.drawable.voicechat_active);
} else {
contentIntent.setContentTitle(LocaleController.getString("VoipOutgoingCall", R.string.VoipOutgoingCall));
contentIntent.setSmallIcon(R.drawable.ic_call);
contentIntent.setOngoing(true);
}
int i3 = Build.VERSION.SDK_INT;
if (i3 >= 16) {
Intent intent = new Intent(this, (Class<?>) VoIPActionsReceiver.class);
intent.setAction(getPackageName() + ".END_CALL");
if (this.groupCall != null) {
int i4 = R.drawable.ic_call_end_white_24dp;
if (ChatObject.isChannelOrGiga(this.chat)) {
i = R.string.VoipChannelLeaveAlertTitle;
str = "VoipChannelLeaveAlertTitle";
} else {
i = R.string.VoipGroupLeaveAlertTitle;
str = "VoipGroupLeaveAlertTitle";
}
contentIntent.addAction(i4, LocaleController.getString(str, i), PendingIntent.getBroadcast(this, 0, intent, 167772160));
} else {
contentIntent.addAction(R.drawable.ic_call_end_white_24dp, LocaleController.getString("VoipEndCall", R.string.VoipEndCall), PendingIntent.getBroadcast(this, 0, intent, 167772160));
}
contentIntent.setPriority(2);
}
if (i3 >= 17) {
contentIntent.setShowWhen(false);
}
if (i3 >= 26) {
contentIntent.setColor(-14143951);
contentIntent.setColorized(true);
} else if (i3 >= 21) {
contentIntent.setColor(Theme.usePlusTheme ? -16738680 : -13851168);
}
if (i3 >= 26) {
NotificationsController.checkOtherNotificationsChannel();
contentIntent.setChannelId(NotificationsController.OTHER_NOTIFICATIONS_CHANNEL);
}
if (photo != null) {
contentIntent.setLargeIcon(photo);
}
try {
startForeground(ID_ONGOING_CALL_NOTIFICATION, contentIntent.getNotification());
} catch (Exception e) {
if (photo == null || !(e instanceof IllegalArgumentException)) {
return;
}
showNotification(name, null);
}
}
private void startRingtoneAndVibration(long r12) {
throw new UnsupportedOperationException("Method not decompiled: org.telegram.messenger.voip.VoIPService.startRingtoneAndVibration(long):void");
}
public void lambda$startRingtoneAndVibration$67(MediaPlayer mediaPlayer) {
try {
this.ringtonePlayer.start();
} catch (Throwable th) {
FileLog.e(th);
}
}
@Override
public void onDestroy() {
if (BuildVars.LOGS_ENABLED) {
FileLog.d("=============== VoIPService STOPPING ===============");
}
stopForeground(true);
stopRinging();
if (this.currentAccount >= 0) {
if (ApplicationLoader.mainInterfacePaused || !ApplicationLoader.isScreenOn) {
MessagesController.getInstance(this.currentAccount).ignoreSetOnline = false;
}
NotificationCenter.getInstance(this.currentAccount).removeObserver(this, NotificationCenter.appDidLogout);
}
SensorManager sensorManager = (SensorManager) getSystemService("sensor");
if (sensorManager.getDefaultSensor(8) != null) {
sensorManager.unregisterListener(this);
}
PowerManager.WakeLock wakeLock = this.proximityWakelock;
if (wakeLock != null && wakeLock.isHeld()) {
this.proximityWakelock.release();
}
if (this.updateNotificationRunnable != null) {
Utilities.globalQueue.cancelRunnable(this.updateNotificationRunnable);
this.updateNotificationRunnable = null;
}
Runnable runnable = this.switchingStreamTimeoutRunnable;
if (runnable != null) {
AndroidUtilities.cancelRunOnUIThread(runnable);
this.switchingStreamTimeoutRunnable = null;
}
unregisterReceiver(this.receiver);
Runnable runnable2 = this.timeoutRunnable;
if (runnable2 != null) {
AndroidUtilities.cancelRunOnUIThread(runnable2);
this.timeoutRunnable = null;
}
super.onDestroy();
sharedInstance = null;
Arrays.fill(this.mySource, 0);
cancelGroupCheckShortPoll();
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.lambda$onDestroy$68();
}
});
if (this.tgVoip[0] != null) {
StatsController.getInstance(this.currentAccount).incrementTotalCallsTime(getStatsNetworkType(), ((int) (getCallDuration() / 1000)) % 5);
onTgVoipPreStop();
if (this.tgVoip[0].isGroup()) {
NativeInstance nativeInstance = this.tgVoip[0];
DispatchQueue dispatchQueue = Utilities.globalQueue;
Objects.requireNonNull(nativeInstance);
dispatchQueue.postRunnable(new VoIPService$$ExternalSyntheticLambda5(nativeInstance));
Iterator<Map.Entry<String, Integer>> it = this.currentStreamRequestTimestamp.entrySet().iterator();
while (it.hasNext()) {
AccountInstance.getInstance(this.currentAccount).getConnectionsManager().cancelRequest(it.next().getValue().intValue(), true);
}
this.currentStreamRequestTimestamp.clear();
} else {
Instance.FinalState stop = this.tgVoip[0].stop();
updateTrafficStats(this.tgVoip[0], stop.trafficStats);
onTgVoipStop(stop);
}
this.prevTrafficStats = null;
this.callStartTime = 0L;
this.tgVoip[0] = null;
Instance.destroyInstance();
}
NativeInstance[] nativeInstanceArr = this.tgVoip;
if (nativeInstanceArr[1] != null) {
NativeInstance nativeInstance2 = nativeInstanceArr[1];
DispatchQueue dispatchQueue2 = Utilities.globalQueue;
Objects.requireNonNull(nativeInstance2);
dispatchQueue2.postRunnable(new VoIPService$$ExternalSyntheticLambda5(nativeInstance2));
this.tgVoip[1] = null;
}
int i = 0;
while (true) {
long[] jArr = this.captureDevice;
if (i >= jArr.length) {
break;
}
if (jArr[i] != 0) {
if (this.destroyCaptureDevice[i]) {
NativeInstance.destroyVideoCapturer(jArr[i]);
}
this.captureDevice[i] = 0;
}
i++;
}
this.cpuWakelock.release();
final AudioManager audioManager = (AudioManager) getSystemService("audio");
if (!this.playingSound) {
VoipAudioManager voipAudioManager = VoipAudioManager.get();
if (!USE_CONNECTION_SERVICE) {
if (this.isBtHeadsetConnected || this.bluetoothScoActive || this.bluetoothScoConnecting) {
audioManager.stopBluetoothSco();
audioManager.setBluetoothScoOn(false);
voipAudioManager.setSpeakerphoneOn(false);
this.bluetoothScoActive = false;
this.bluetoothScoConnecting = false;
}
if (this.onDestroyRunnable == null) {
DispatchQueue dispatchQueue3 = Utilities.globalQueue;
Runnable runnable3 = new Runnable() {
@Override
public final void run() {
VoIPService.lambda$onDestroy$69(audioManager);
}
};
setModeRunnable = runnable3;
dispatchQueue3.postRunnable(runnable3);
}
audioManager.abandonAudioFocus(this);
}
try {
audioManager.unregisterMediaButtonEventReceiver(new ComponentName(this, (Class<?>) VoIPMediaButtonReceiver.class));
} catch (Exception e) {
FileLog.e(e);
}
AudioDeviceCallback audioDeviceCallback = this.audioDeviceCallback;
if (audioDeviceCallback != null) {
audioManager.unregisterAudioDeviceCallback(audioDeviceCallback);
}
Utilities.globalQueue.postRunnable(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$onDestroy$70();
}
});
}
if (this.hasAudioFocus) {
audioManager.abandonAudioFocus(this);
}
if (USE_CONNECTION_SERVICE) {
if (!this.didDeleteConnectionServiceContact) {
ContactsController.getInstance(this.currentAccount).deleteConnectionServiceContact();
}
CallConnection callConnection = this.systemCallConnection;
if (callConnection != null && !this.playingSound) {
callConnection.destroy();
}
}
VoIPHelper.lastCallTime = SystemClock.elapsedRealtime();
setSinks(null, null);
Runnable runnable4 = this.onDestroyRunnable;
if (runnable4 != null) {
runnable4.run();
}
int i2 = this.currentAccount;
if (i2 >= 0) {
ConnectionsManager.getInstance(i2).setAppPaused(true, false);
if (ChatObject.isChannel(this.chat)) {
MessagesController.getInstance(this.currentAccount).startShortPoll(this.chat, this.classGuid, true);
}
}
}
public static void lambda$onDestroy$68() {
NotificationCenter.getGlobalInstance().lambda$postNotificationNameOnUIThread$1(NotificationCenter.didEndCall, new Object[0]);
}
public static void lambda$onDestroy$69(AudioManager audioManager) {
synchronized (sync) {
if (setModeRunnable == null) {
return;
}
setModeRunnable = null;
try {
audioManager.setMode(0);
} catch (SecurityException e) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("Error setting audio more to normal", e);
}
}
}
}
public void lambda$onDestroy$70() {
SoundPool soundPool = this.soundPool;
if (soundPool != null) {
soundPool.release();
}
}
public long getCallID() {
TLRPC.PhoneCall phoneCall = this.privateCall;
if (phoneCall != null) {
return phoneCall.id;
}
return 0L;
}
public void hangUp() {
hangUp(0, null);
}
public void hangUp(int discard) {
hangUp(discard, null);
}
public void hangUp(Runnable onDone) {
hangUp(0, onDone);
}
public void acceptIncomingCall() {
MessagesController.getInstance(this.currentAccount).ignoreSetOnline = false;
stopRinging();
showNotification();
configureDeviceForCall();
startConnectingSound();
dispatchStateChanged(12);
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.lambda$acceptIncomingCall$71();
}
});
final MessagesStorage messagesStorage = MessagesStorage.getInstance(this.currentAccount);
TLRPC.TL_messages_getDhConfig tL_messages_getDhConfig = new TLRPC.TL_messages_getDhConfig();
tL_messages_getDhConfig.random_length = 256;
tL_messages_getDhConfig.version = messagesStorage.getLastSecretVersion();
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_messages_getDhConfig, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.this.lambda$acceptIncomingCall$74(messagesStorage, tLObject, tL_error);
}
});
}
public static void lambda$acceptIncomingCall$71() {
NotificationCenter.getGlobalInstance().lambda$postNotificationNameOnUIThread$1(NotificationCenter.didStartedCall, new Object[0]);
}
public void lambda$acceptIncomingCall$74(MessagesStorage messagesStorage, TLObject tLObject, TLRPC.TL_error tL_error) {
if (tL_error == null) {
TLRPC.messages_DhConfig messages_dhconfig = (TLRPC.messages_DhConfig) tLObject;
if (tLObject instanceof TLRPC.TL_messages_dhConfig) {
if (!Utilities.isGoodPrime(messages_dhconfig.p, messages_dhconfig.g)) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("stopping VoIP service, bad prime");
}
callFailed();
return;
} else {
messagesStorage.setSecretPBytes(messages_dhconfig.p);
messagesStorage.setSecretG(messages_dhconfig.g);
messagesStorage.setLastSecretVersion(messages_dhconfig.version);
MessagesStorage.getInstance(this.currentAccount).saveSecretParams(messagesStorage.getLastSecretVersion(), messagesStorage.getSecretG(), messagesStorage.getSecretPBytes());
}
}
byte[] bArr = new byte[256];
for (int i = 0; i < 256; i++) {
bArr[i] = (byte) (((byte) (Utilities.random.nextDouble() * 256.0d)) ^ messages_dhconfig.random[i]);
}
if (this.privateCall == null) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("call is null");
}
callFailed();
return;
}
this.a_or_b = bArr;
BigInteger modPow = BigInteger.valueOf(messagesStorage.getSecretG()).modPow(new BigInteger(1, bArr), new BigInteger(1, messagesStorage.getSecretPBytes()));
this.g_a_hash = this.privateCall.g_a_hash;
byte[] byteArray = modPow.toByteArray();
if (byteArray.length > 256) {
byte[] bArr2 = new byte[256];
System.arraycopy(byteArray, 1, bArr2, 0, 256);
byteArray = bArr2;
}
TLRPC.TL_phone_acceptCall tL_phone_acceptCall = new TLRPC.TL_phone_acceptCall();
tL_phone_acceptCall.g_b = byteArray;
TLRPC.TL_inputPhoneCall tL_inputPhoneCall = new TLRPC.TL_inputPhoneCall();
tL_phone_acceptCall.peer = tL_inputPhoneCall;
TLRPC.PhoneCall phoneCall = this.privateCall;
tL_inputPhoneCall.id = phoneCall.id;
tL_inputPhoneCall.access_hash = phoneCall.access_hash;
TLRPC.TL_phoneCallProtocol tL_phoneCallProtocol = new TLRPC.TL_phoneCallProtocol();
tL_phone_acceptCall.protocol = tL_phoneCallProtocol;
tL_phoneCallProtocol.udp_reflector = true;
tL_phoneCallProtocol.udp_p2p = true;
tL_phoneCallProtocol.min_layer = 65;
tL_phoneCallProtocol.max_layer = Instance.getConnectionMaxLayer();
tL_phone_acceptCall.protocol.library_versions.addAll(Instance.AVAILABLE_VERSIONS);
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_phone_acceptCall, new RequestDelegate() {
@Override
public final void run(TLObject tLObject2, TLRPC.TL_error tL_error2) {
VoIPService.this.lambda$acceptIncomingCall$73(tLObject2, tL_error2);
}
}, 2);
return;
}
callFailed();
}
public void lambda$acceptIncomingCall$73(final TLObject tLObject, final TLRPC.TL_error tL_error) {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$acceptIncomingCall$72(tL_error, tLObject);
}
});
}
public void lambda$acceptIncomingCall$72(TLRPC.TL_error tL_error, TLObject tLObject) {
if (tL_error == null) {
if (BuildVars.LOGS_ENABLED) {
FileLog.w("accept call ok! " + tLObject);
}
TLRPC.PhoneCall phoneCall = ((TLRPC.TL_phone_phoneCall) tLObject).phone_call;
this.privateCall = phoneCall;
if (phoneCall instanceof TLRPC.TL_phoneCallDiscarded) {
onCallUpdated(phoneCall);
return;
}
return;
}
if (BuildVars.LOGS_ENABLED) {
FileLog.e("Error on phone.acceptCall: " + tL_error);
}
callFailed();
}
public void declineIncomingCall(int reason, final Runnable onDone) {
if (this.groupCall != null) {
stopScreenCapture();
}
stopRinging();
this.callDiscardReason = reason;
int i = this.currentState;
if (i == 14) {
Runnable runnable = this.delayedStartOutgoingCall;
if (runnable != null) {
AndroidUtilities.cancelRunOnUIThread(runnable);
callEnded();
return;
} else {
dispatchStateChanged(10);
this.endCallAfterRequest = true;
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$declineIncomingCall$75();
}
}, 5000L);
return;
}
}
if (i == 10 || i == 11) {
return;
}
dispatchStateChanged(10);
if (this.privateCall == null) {
this.onDestroyRunnable = onDone;
callEnded();
if (this.callReqId != 0) {
ConnectionsManager.getInstance(this.currentAccount).cancelRequest(this.callReqId, false);
this.callReqId = 0;
return;
}
return;
}
TLRPC.TL_phone_discardCall tL_phone_discardCall = new TLRPC.TL_phone_discardCall();
TLRPC.TL_inputPhoneCall tL_inputPhoneCall = new TLRPC.TL_inputPhoneCall();
tL_phone_discardCall.peer = tL_inputPhoneCall;
TLRPC.PhoneCall phoneCall = this.privateCall;
tL_inputPhoneCall.access_hash = phoneCall.access_hash;
tL_inputPhoneCall.id = phoneCall.id;
tL_phone_discardCall.duration = (int) (getCallDuration() / 1000);
NativeInstance[] nativeInstanceArr = this.tgVoip;
tL_phone_discardCall.connection_id = nativeInstanceArr[0] != null ? nativeInstanceArr[0].getPreferredRelayId() : 0L;
if (reason == 2) {
tL_phone_discardCall.reason = new TLRPC.TL_phoneCallDiscardReasonDisconnect();
} else if (reason == 3) {
tL_phone_discardCall.reason = new TLRPC.TL_phoneCallDiscardReasonMissed();
} else if (reason == 4) {
tL_phone_discardCall.reason = new TLRPC.TL_phoneCallDiscardReasonBusy();
} else {
tL_phone_discardCall.reason = new TLRPC.TL_phoneCallDiscardReasonHangup();
}
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_phone_discardCall, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.this.lambda$declineIncomingCall$76(tLObject, tL_error);
}
}, 2);
this.onDestroyRunnable = onDone;
callEnded();
}
public void lambda$declineIncomingCall$75() {
if (this.currentState == 10) {
callEnded();
}
}
public void lambda$declineIncomingCall$76(TLObject tLObject, TLRPC.TL_error tL_error) {
if (tL_error != null) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("error on phone.discardCall: " + tL_error);
return;
}
return;
}
if (tLObject instanceof TLRPC.TL_updates) {
MessagesController.getInstance(this.currentAccount).processUpdates((TLRPC.TL_updates) tLObject, false);
}
if (BuildVars.LOGS_ENABLED) {
FileLog.d("phone.discardCall " + tLObject);
}
}
public void declineIncomingCall() {
declineIncomingCall(1, null);
}
private Class<? extends Activity> getUIActivityClass() {
return LaunchActivity.class;
}
@TargetApi(26)
public CallConnection getConnectionAndStartCall() {
if (this.systemCallConnection == null) {
if (BuildVars.LOGS_ENABLED) {
FileLog.d("creating call connection");
}
CallConnection callConnection = new CallConnection();
this.systemCallConnection = callConnection;
callConnection.setInitializing();
if (this.isOutgoing) {
Runnable runnable = new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$getConnectionAndStartCall$77();
}
};
this.delayedStartOutgoingCall = runnable;
AndroidUtilities.runOnUIThread(runnable, 2000L);
}
this.systemCallConnection.setAddress(Uri.fromParts("tel", "+99084" + this.user.id, null), 1);
CallConnection callConnection2 = this.systemCallConnection;
TLRPC.User user = this.user;
callConnection2.setCallerDisplayName(ContactsController.formatName(user.first_name, user.last_name), 1);
}
return this.systemCallConnection;
}
public void lambda$getConnectionAndStartCall$77() {
this.delayedStartOutgoingCall = null;
startOutgoingCall();
}
public void startRinging() {
CallConnection callConnection;
if (this.currentState == 15) {
return;
}
if (USE_CONNECTION_SERVICE && (callConnection = this.systemCallConnection) != null) {
callConnection.setRinging();
}
if (BuildVars.LOGS_ENABLED) {
FileLog.d("starting ringing for call " + this.privateCall.id);
}
dispatchStateChanged(15);
if (!this.notificationsDisabled && Build.VERSION.SDK_INT >= 21) {
TLRPC.User user = this.user;
showIncomingNotification(ContactsController.formatName(user.first_name, user.last_name), this.user, this.privateCall.video, 0);
if (BuildVars.LOGS_ENABLED) {
FileLog.d("Showing incoming call notification");
return;
}
return;
}
startRingtoneAndVibration(this.user.id);
if (BuildVars.LOGS_ENABLED) {
FileLog.d("Starting incall activity for incoming call");
}
try {
PendingIntent.getActivity(this, 12345, new Intent(this, (Class<?>) LaunchActivity.class).setAction("voip"), 33554432).send();
} catch (Exception e) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("Error starting incall activity", e);
}
}
}
public void startRingtoneAndVibration() {
if (this.startedRinging) {
return;
}
startRingtoneAndVibration(this.user.id);
this.startedRinging = true;
}
private void updateServerConfig() {
final SharedPreferences mainSettings = MessagesController.getMainSettings(this.currentAccount);
Instance.setGlobalServerConfig(mainSettings.getString("voip_server_config", "{}"));
ConnectionsManager.getInstance(this.currentAccount).sendRequest(new TLRPC.TL_phone_getCallConfig(), new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.lambda$updateServerConfig$78(mainSettings, tLObject, tL_error);
}
});
}
public static void lambda$updateServerConfig$78(SharedPreferences sharedPreferences, TLObject tLObject, TLRPC.TL_error tL_error) {
if (tL_error == null) {
String str = ((TLRPC.TL_dataJSON) tLObject).data;
Instance.setGlobalServerConfig(str);
sharedPreferences.edit().putString("voip_server_config", str).commit();
}
}
private void showNotification() {
TLRPC.User user = this.user;
if (user != null) {
showNotification(ContactsController.formatName(user.first_name, user.last_name), getRoundAvatarBitmap(this.user));
} else {
TLRPC.Chat chat = this.chat;
showNotification(chat.title, getRoundAvatarBitmap(chat));
}
}
public static String convertStreamToString(InputStream is) throws Exception {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(is));
StringBuilder sb = new StringBuilder();
while (true) {
String readLine = bufferedReader.readLine();
if (readLine != null) {
sb.append(readLine);
sb.append("\n");
} else {
bufferedReader.close();
return sb.toString();
}
}
}
public static String getStringFromFile(String filePath) throws Exception {
FileInputStream fileInputStream = new FileInputStream(new File(filePath));
String convertStreamToString = convertStreamToString(fileInputStream);
fileInputStream.close();
return convertStreamToString;
}
public boolean hasRate() {
return this.needRateCall || this.forceRating;
}
private void onTgVoipStop(Instance.FinalState finalState) {
if (this.user == null) {
return;
}
if (TextUtils.isEmpty(finalState.debugLog)) {
try {
finalState.debugLog = getStringFromFile(VoIPHelper.getLogFilePath(this.privateCall.id, true));
} catch (Exception e) {
e.printStackTrace();
}
}
if (!this.needSendDebugLog || finalState.debugLog == null) {
return;
}
TLRPC.TL_phone_saveCallDebug tL_phone_saveCallDebug = new TLRPC.TL_phone_saveCallDebug();
TLRPC.TL_dataJSON tL_dataJSON = new TLRPC.TL_dataJSON();
tL_phone_saveCallDebug.debug = tL_dataJSON;
tL_dataJSON.data = finalState.debugLog;
TLRPC.TL_inputPhoneCall tL_inputPhoneCall = new TLRPC.TL_inputPhoneCall();
tL_phone_saveCallDebug.peer = tL_inputPhoneCall;
TLRPC.PhoneCall phoneCall = this.privateCall;
tL_inputPhoneCall.access_hash = phoneCall.access_hash;
tL_inputPhoneCall.id = phoneCall.id;
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_phone_saveCallDebug, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.lambda$onTgVoipStop$79(tLObject, tL_error);
}
});
this.needSendDebugLog = false;
}
public static void lambda$onTgVoipStop$79(TLObject tLObject, TLRPC.TL_error tL_error) {
if (BuildVars.LOGS_ENABLED) {
FileLog.d("Sent debug logs, response = " + tLObject);
}
}
private void initializeAccountRelatedThings() {
updateServerConfig();
NotificationCenter.getInstance(this.currentAccount).addObserver(this, NotificationCenter.appDidLogout);
ConnectionsManager.getInstance(this.currentAccount).setAppPaused(false, false);
}
@Override
@SuppressLint({"InvalidWakeLockTag"})
public void onCreate() {
super.onCreate();
if (BuildVars.LOGS_ENABLED) {
FileLog.d("=============== VoIPService STARTING ===============");
}
try {
AudioManager audioManager = (AudioManager) getSystemService("audio");
if (audioManager.getProperty("android.media.property.OUTPUT_FRAMES_PER_BUFFER") != null) {
Instance.setBufferSize(Integer.parseInt(audioManager.getProperty("android.media.property.OUTPUT_FRAMES_PER_BUFFER")));
} else {
Instance.setBufferSize(AudioTrack.getMinBufferSize(48000, 4, 2) / 2);
}
PowerManager.WakeLock newWakeLock = ((PowerManager) getSystemService("power")).newWakeLock(1, "telegram-voip");
this.cpuWakelock = newWakeLock;
newWakeLock.acquire();
this.btAdapter = audioManager.isBluetoothScoAvailableOffCall() ? BluetoothAdapter.getDefaultAdapter() : null;
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
if (!USE_CONNECTION_SERVICE) {
intentFilter.addAction(ACTION_HEADSET_PLUG);
if (this.btAdapter != null) {
intentFilter.addAction("android.bluetooth.headset.profile.action.CONNECTION_STATE_CHANGED");
intentFilter.addAction("android.media.ACTION_SCO_AUDIO_STATE_UPDATED");
}
intentFilter.addAction("android.intent.action.PHONE_STATE");
intentFilter.addAction("android.intent.action.SCREEN_ON");
intentFilter.addAction("android.intent.action.SCREEN_OFF");
}
registerReceiver(this.receiver, intentFilter);
fetchBluetoothDeviceName();
if (this.audioDeviceCallback == null) {
try {
this.audioDeviceCallback = new AudioDeviceCallback() {
@Override
public void onAudioDevicesAdded(AudioDeviceInfo[] addedDevices) {
VoIPService.this.checkUpdateBluetoothHeadset();
}
@Override
public void onAudioDevicesRemoved(AudioDeviceInfo[] removedDevices) {
VoIPService.this.checkUpdateBluetoothHeadset();
}
};
} catch (Throwable th) {
FileLog.e(th);
this.audioDeviceCallback = null;
}
}
AudioDeviceCallback audioDeviceCallback = this.audioDeviceCallback;
if (audioDeviceCallback != null) {
audioManager.registerAudioDeviceCallback(audioDeviceCallback, new Handler(Looper.getMainLooper()));
}
audioManager.registerMediaButtonEventReceiver(new ComponentName(this, (Class<?>) VoIPMediaButtonReceiver.class));
checkUpdateBluetoothHeadset();
} catch (Exception e) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("error initializing voip controller", e);
}
callFailed();
}
if (callIShouldHavePutIntoIntent == null || Build.VERSION.SDK_INT < 26) {
return;
}
NotificationsController.checkOtherNotificationsChannel();
Notification.Builder showWhen = new Notification.Builder(this, NotificationsController.OTHER_NOTIFICATIONS_CHANNEL).setContentTitle(LocaleController.getString("VoipOutgoingCall", R.string.VoipOutgoingCall)).setShowWhen(false);
if (this.groupCall != null) {
showWhen.setSmallIcon(isMicMute() ? R.drawable.voicechat_muted : R.drawable.voicechat_active);
} else {
showWhen.setSmallIcon(R.drawable.ic_call);
}
startForeground(ID_ONGOING_CALL_NOTIFICATION, showWhen.build());
}
public void checkUpdateBluetoothHeadset() {
BluetoothAdapter bluetoothAdapter;
if (USE_CONNECTION_SERVICE || (bluetoothAdapter = this.btAdapter) == null || !bluetoothAdapter.isEnabled()) {
return;
}
try {
MediaRouter mediaRouter = (MediaRouter) getSystemService("media_router");
AudioManager audioManager = (AudioManager) getSystemService("audio");
if (Build.VERSION.SDK_INT < 24) {
updateBluetoothHeadsetState(this.btAdapter.getProfileConnectionState(1) == 2);
Iterator<StateListener> it = this.stateListeners.iterator();
while (it.hasNext()) {
it.next().onAudioSettingsChanged();
}
return;
}
if (mediaRouter.getSelectedRoute(1).getDeviceType() == 3) {
updateBluetoothHeadsetState(this.btAdapter.getProfileConnectionState(1) == 2);
Iterator<StateListener> it2 = this.stateListeners.iterator();
while (it2.hasNext()) {
it2.next().onAudioSettingsChanged();
}
return;
}
updateBluetoothHeadsetState(audioManager.isBluetoothA2dpOn());
} catch (Throwable th) {
FileLog.e(th);
}
}
private void loadResources() {
if (Build.VERSION.SDK_INT >= 21) {
WebRtcAudioTrack.setAudioTrackUsageAttribute(2);
}
Utilities.globalQueue.postRunnable(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$loadResources$80();
}
});
}
public void lambda$loadResources$80() {
SoundPool soundPool = new SoundPool(1, 0, 0);
this.soundPool = soundPool;
this.spConnectingId = soundPool.load(this, R.raw.voip_connecting, 1);
this.spRingbackID = this.soundPool.load(this, R.raw.voip_ringback, 1);
this.spFailedID = this.soundPool.load(this, R.raw.voip_failed, 1);
this.spEndId = this.soundPool.load(this, R.raw.voip_end, 1);
this.spBusyId = this.soundPool.load(this, R.raw.voip_busy, 1);
this.spVoiceChatEndId = this.soundPool.load(this, R.raw.voicechat_leave, 1);
this.spVoiceChatStartId = this.soundPool.load(this, R.raw.voicechat_join, 1);
this.spVoiceChatConnecting = this.soundPool.load(this, R.raw.voicechat_connecting, 1);
this.spAllowTalkId = this.soundPool.load(this, R.raw.voip_onallowtalk, 1);
this.spStartRecordId = this.soundPool.load(this, R.raw.voip_recordstart, 1);
}
private void dispatchStateChanged(int state) {
CallConnection callConnection;
if (BuildVars.LOGS_ENABLED) {
FileLog.d("== Call " + getCallID() + " state changed to " + state + " ==");
}
this.currentState = state;
if (USE_CONNECTION_SERVICE && state == 3 && (callConnection = this.systemCallConnection) != null) {
callConnection.setActive();
}
for (int i = 0; i < this.stateListeners.size(); i++) {
this.stateListeners.get(i).onStateChanged(state);
}
}
public void updateTrafficStats(NativeInstance instance, Instance.TrafficStats trafficStats) {
if (trafficStats == null) {
trafficStats = instance.getTrafficStats();
}
long j = trafficStats.bytesSentWifi;
Instance.TrafficStats trafficStats2 = this.prevTrafficStats;
long j2 = j - (trafficStats2 != null ? trafficStats2.bytesSentWifi : 0L);
long j3 = trafficStats.bytesReceivedWifi - (trafficStats2 != null ? trafficStats2.bytesReceivedWifi : 0L);
long j4 = trafficStats.bytesSentMobile - (trafficStats2 != null ? trafficStats2.bytesSentMobile : 0L);
long j5 = trafficStats.bytesReceivedMobile - (trafficStats2 != null ? trafficStats2.bytesReceivedMobile : 0L);
this.prevTrafficStats = trafficStats;
if (j2 > 0) {
StatsController.getInstance(this.currentAccount).incrementSentBytesCount(1, 0, j2);
}
if (j3 > 0) {
StatsController.getInstance(this.currentAccount).incrementReceivedBytesCount(1, 0, j3);
}
if (j4 > 0) {
StatsController statsController = StatsController.getInstance(this.currentAccount);
NetworkInfo networkInfo = this.lastNetInfo;
statsController.incrementSentBytesCount((networkInfo == null || !networkInfo.isRoaming()) ? 0 : 2, 0, j4);
}
if (j5 > 0) {
StatsController statsController2 = StatsController.getInstance(this.currentAccount);
NetworkInfo networkInfo2 = this.lastNetInfo;
statsController2.incrementReceivedBytesCount((networkInfo2 == null || !networkInfo2.isRoaming()) ? 0 : 2, 0, j5);
}
}
@SuppressLint({"InvalidWakeLockTag"})
private void configureDeviceForCall() {
if (BuildVars.LOGS_ENABLED) {
FileLog.d("configureDeviceForCall, route to set = " + this.audioRouteToSet);
}
if (Build.VERSION.SDK_INT >= 21) {
WebRtcAudioTrack.setAudioTrackUsageAttribute(hasRtmpStream() ? 1 : 2);
WebRtcAudioTrack.setAudioStreamType(hasRtmpStream() ? Integer.MIN_VALUE : 0);
}
this.needPlayEndSound = true;
final AudioManager audioManager = (AudioManager) getSystemService("audio");
if (!USE_CONNECTION_SERVICE) {
Utilities.globalQueue.postRunnable(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$configureDeviceForCall$83(audioManager);
}
});
}
SensorManager sensorManager = (SensorManager) getSystemService("sensor");
Sensor defaultSensor = sensorManager.getDefaultSensor(8);
if (defaultSensor != null) {
try {
this.proximityWakelock = ((PowerManager) getSystemService("power")).newWakeLock(32, "telegram-voip-prx");
sensorManager.registerListener(this, defaultSensor, 3);
} catch (Exception e) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("Error initializing proximity sensor", e);
}
}
}
}
public void lambda$configureDeviceForCall$83(final AudioManager audioManager) {
try {
} catch (Exception e) {
FileLog.e(e);
}
if (hasRtmpStream()) {
audioManager.setMode(0);
audioManager.setBluetoothScoOn(false);
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.lambda$configureDeviceForCall$81();
}
});
} else {
audioManager.setMode(3);
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$configureDeviceForCall$82(audioManager);
}
});
}
}
public static void lambda$configureDeviceForCall$81() {
if (MediaController.getInstance().isMessagePaused()) {
return;
}
MediaController.getInstance().pauseMessage(MediaController.getInstance().getPlayingMessageObject());
}
public void lambda$configureDeviceForCall$82(AudioManager audioManager) {
this.hasAudioFocus = audioManager.requestAudioFocus(this, 0, 2) == 1;
VoipAudioManager voipAudioManager = VoipAudioManager.get();
if (isBluetoothHeadsetConnected() && hasEarpiece()) {
int i = this.audioRouteToSet;
if (i == 0) {
audioManager.setBluetoothScoOn(false);
voipAudioManager.setSpeakerphoneOn(false);
} else if (i == 1) {
audioManager.setBluetoothScoOn(false);
voipAudioManager.setSpeakerphoneOn(true);
} else if (i == 2) {
if (!this.bluetoothScoActive) {
this.needSwitchToBluetoothAfterScoActivates = true;
try {
audioManager.startBluetoothSco();
} catch (Throwable th) {
FileLog.e(th);
}
} else {
audioManager.setBluetoothScoOn(true);
voipAudioManager.setSpeakerphoneOn(false);
}
}
} else if (isBluetoothHeadsetConnected()) {
audioManager.setBluetoothScoOn(this.speakerphoneStateToSet);
} else {
voipAudioManager.setSpeakerphoneOn(this.speakerphoneStateToSet);
if (this.speakerphoneStateToSet) {
this.audioRouteToSet = 1;
} else {
this.audioRouteToSet = 0;
}
SensorEvent sensorEvent = this.lastSensorEvent;
if (sensorEvent != null) {
onSensorChanged(sensorEvent);
}
}
updateOutputGainControlState();
this.audioConfigured = true;
}
public void fetchBluetoothDeviceName() {
if (this.fetchingBluetoothDeviceName) {
return;
}
try {
this.currentBluetoothDeviceName = null;
this.fetchingBluetoothDeviceName = true;
BluetoothAdapter.getDefaultAdapter().getProfileProxy(this, this.serviceListener, 1);
} catch (Throwable th) {
FileLog.e(th);
}
}
@Override
@SuppressLint({"NewApi"})
public void onSensorChanged(SensorEvent event) {
this.lastSensorEvent = event;
if (this.unmutedByHold || this.remoteVideoState == 2 || this.videoState[0] == 2 || event.sensor.getType() != 8) {
return;
}
AudioManager audioManager = (AudioManager) getSystemService("audio");
VoipAudioManager voipAudioManager = VoipAudioManager.get();
if (this.audioRouteToSet != 0 || this.isHeadsetPlugged || voipAudioManager.isSpeakerphoneOn()) {
return;
}
if (isBluetoothHeadsetConnected() && audioManager.isBluetoothScoOn()) {
return;
}
boolean z = event.values[0] < Math.min(event.sensor.getMaximumRange(), 3.0f);
checkIsNear(z);
NotificationCenter.getGlobalInstance().lambda$postNotificationNameOnUIThread$1(NotificationCenter.nearEarEvent, Boolean.valueOf(z));
}
private void checkIsNear() {
if (this.remoteVideoState == 2 || this.videoState[0] == 2) {
checkIsNear(false);
}
}
private void checkIsNear(boolean newIsNear) {
if (newIsNear != this.isProximityNear) {
if (BuildVars.LOGS_ENABLED) {
FileLog.d("proximity " + newIsNear);
}
this.isProximityNear = newIsNear;
try {
if (newIsNear) {
this.proximityWakelock.acquire();
} else {
this.proximityWakelock.release(1);
}
} catch (Exception e) {
FileLog.e(e);
}
}
}
public boolean isBluetoothHeadsetConnected() {
CallConnection callConnection;
if (!USE_CONNECTION_SERVICE || (callConnection = this.systemCallConnection) == null || callConnection.getCallAudioState() == null) {
return this.isBtHeadsetConnected;
}
return (this.systemCallConnection.getCallAudioState().getSupportedRouteMask() & 2) != 0;
}
@Override
public void onAudioFocusChange(int focusChange) {
if (focusChange == 1) {
this.hasAudioFocus = true;
} else {
this.hasAudioFocus = false;
}
}
public void updateBluetoothHeadsetState(boolean connected) {
if (connected == this.isBtHeadsetConnected) {
return;
}
if (BuildVars.LOGS_ENABLED) {
FileLog.d("updateBluetoothHeadsetState: " + connected);
}
this.isBtHeadsetConnected = connected;
final AudioManager audioManager = (AudioManager) getSystemService("audio");
if (connected && !isRinging() && this.currentState != 0) {
if (this.bluetoothScoActive) {
if (BuildVars.LOGS_ENABLED) {
FileLog.d("SCO already active, setting audio routing");
}
if (!hasRtmpStream()) {
audioManager.setSpeakerphoneOn(false);
audioManager.setBluetoothScoOn(true);
}
} else {
if (BuildVars.LOGS_ENABLED) {
FileLog.d("startBluetoothSco");
}
if (!hasRtmpStream()) {
this.needSwitchToBluetoothAfterScoActivates = true;
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.lambda$updateBluetoothHeadsetState$84(audioManager);
}
}, 500L);
}
}
} else {
this.bluetoothScoActive = false;
this.bluetoothScoConnecting = false;
audioManager.setBluetoothScoOn(false);
}
Iterator<StateListener> it = this.stateListeners.iterator();
while (it.hasNext()) {
it.next().onAudioSettingsChanged();
}
}
public static void lambda$updateBluetoothHeadsetState$84(AudioManager audioManager) {
try {
audioManager.startBluetoothSco();
} catch (Throwable unused) {
}
}
public String getLastError() {
return this.lastError;
}
public int getCallState() {
return this.currentState;
}
public TLRPC.InputPeer getGroupCallPeer() {
return this.groupCallPeer;
}
public void updateNetworkType() {
NativeInstance[] nativeInstanceArr = this.tgVoip;
if (nativeInstanceArr[0] != null) {
if (nativeInstanceArr[0].isGroup()) {
return;
}
this.tgVoip[0].setNetworkType(getNetworkType());
return;
}
this.lastNetInfo = getActiveNetworkInfo();
}
private int getNetworkType() {
NetworkInfo activeNetworkInfo = getActiveNetworkInfo();
this.lastNetInfo = activeNetworkInfo;
if (activeNetworkInfo != null) {
int type = activeNetworkInfo.getType();
if (type == 0) {
switch (activeNetworkInfo.getSubtype()) {
case 1:
return 1;
case 2:
case 7:
return 2;
case 3:
case 5:
return 3;
case 4:
case 11:
case 14:
default:
return 11;
case 6:
case 8:
case 9:
case 10:
case 12:
case 15:
return 4;
case 13:
return 5;
}
}
if (type == 1) {
return 6;
}
if (type == 9) {
return 7;
}
}
return 0;
}
private NetworkInfo getActiveNetworkInfo() {
return ((ConnectivityManager) getSystemService("connectivity")).getActiveNetworkInfo();
}
public void callFailed() {
NativeInstance[] nativeInstanceArr = this.tgVoip;
callFailed(nativeInstanceArr[0] != null ? nativeInstanceArr[0].getLastError() : Instance.ERROR_UNKNOWN);
}
private android.graphics.Bitmap getRoundAvatarBitmap(org.telegram.tgnet.TLObject r8) {
throw new UnsupportedOperationException("Method not decompiled: org.telegram.messenger.voip.VoIPService.getRoundAvatarBitmap(org.telegram.tgnet.TLObject):android.graphics.Bitmap");
}
private void showIncomingNotification(java.lang.String r20, org.telegram.tgnet.TLObject r21, boolean r22, int r23) {
throw new UnsupportedOperationException("Method not decompiled: org.telegram.messenger.voip.VoIPService.showIncomingNotification(java.lang.String, org.telegram.tgnet.TLObject, boolean, int):void");
}
private void callFailed(String error) {
CallConnection callConnection;
if (this.privateCall != null) {
if (BuildVars.LOGS_ENABLED) {
FileLog.d("Discarding failed call");
}
TLRPC.TL_phone_discardCall tL_phone_discardCall = new TLRPC.TL_phone_discardCall();
TLRPC.TL_inputPhoneCall tL_inputPhoneCall = new TLRPC.TL_inputPhoneCall();
tL_phone_discardCall.peer = tL_inputPhoneCall;
TLRPC.PhoneCall phoneCall = this.privateCall;
tL_inputPhoneCall.access_hash = phoneCall.access_hash;
tL_inputPhoneCall.id = phoneCall.id;
tL_phone_discardCall.duration = (int) (getCallDuration() / 1000);
NativeInstance[] nativeInstanceArr = this.tgVoip;
tL_phone_discardCall.connection_id = nativeInstanceArr[0] != null ? nativeInstanceArr[0].getPreferredRelayId() : 0L;
tL_phone_discardCall.reason = new TLRPC.TL_phoneCallDiscardReasonDisconnect();
ConnectionsManager.getInstance(this.currentAccount).sendRequest(tL_phone_discardCall, new RequestDelegate() {
@Override
public final void run(TLObject tLObject, TLRPC.TL_error tL_error) {
VoIPService.lambda$callFailed$85(tLObject, tL_error);
}
});
}
try {
throw new Exception("Call " + getCallID() + " failed with error: " + error);
} catch (Exception e) {
FileLog.e(e);
this.lastError = error;
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$callFailed$86();
}
});
if (TextUtils.equals(error, Instance.ERROR_LOCALIZED) && this.soundPool != null) {
this.playingSound = true;
Utilities.globalQueue.postRunnable(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$callFailed$87();
}
});
AndroidUtilities.runOnUIThread(this.afterSoundRunnable, 1000L);
}
if (USE_CONNECTION_SERVICE && (callConnection = this.systemCallConnection) != null) {
callConnection.setDisconnected(new DisconnectCause(1));
this.systemCallConnection.destroy();
this.systemCallConnection = null;
}
stopSelf();
}
}
public static void lambda$callFailed$85(TLObject tLObject, TLRPC.TL_error tL_error) {
if (tL_error != null) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("error on phone.discardCall: " + tL_error);
return;
}
return;
}
if (BuildVars.LOGS_ENABLED) {
FileLog.d("phone.discardCall " + tLObject);
}
}
public void lambda$callFailed$86() {
dispatchStateChanged(4);
}
public void lambda$callFailed$87() {
this.soundPool.play(this.spFailedID, 1.0f, 1.0f, 0, 0, 1.0f);
}
public void callFailedFromConnectionService() {
if (this.isOutgoing) {
callFailed(Instance.ERROR_CONNECTION_SERVICE);
} else {
hangUp();
}
}
@Override
public void onConnectionStateChanged(final int newState, boolean inTransition) {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$onConnectionStateChanged$90(newState);
}
});
}
public void lambda$onConnectionStateChanged$90(int i) {
if (i == 3 && this.callStartTime == 0) {
this.callStartTime = SystemClock.elapsedRealtime();
}
if (i == 4) {
callFailed();
return;
}
if (i == 3) {
Runnable runnable = this.connectingSoundRunnable;
if (runnable != null) {
AndroidUtilities.cancelRunOnUIThread(runnable);
this.connectingSoundRunnable = null;
}
Utilities.globalQueue.postRunnable(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$onConnectionStateChanged$88();
}
});
if (this.groupCall == null && !this.wasEstablished) {
this.wasEstablished = true;
if (!this.isProximityNear && !this.privateCall.video && !PlusSettings.disableActionsVibrations) {
try {
LaunchActivity.getLastFragment().getFragmentView().performHapticFeedback(3, 2);
} catch (Exception unused) {
}
}
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public void run() {
if (VoIPService.this.tgVoip[0] != null) {
StatsController.getInstance(VoIPService.this.currentAccount).incrementTotalCallsTime(VoIPService.this.getStatsNetworkType(), 5);
AndroidUtilities.runOnUIThread(this, 5000L);
}
}
}, 5000L);
if (this.isOutgoing) {
StatsController.getInstance(this.currentAccount).incrementSentItemsCount(getStatsNetworkType(), 0, 1);
} else {
StatsController.getInstance(this.currentAccount).incrementReceivedItemsCount(getStatsNetworkType(), 0, 1);
}
}
}
if (i == 5 && !this.isCallEnded) {
Utilities.globalQueue.postRunnable(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$onConnectionStateChanged$89();
}
});
}
dispatchStateChanged(i);
}
public void lambda$onConnectionStateChanged$88() {
int i = this.spPlayId;
if (i != 0) {
this.soundPool.stop(i);
this.spPlayId = 0;
}
}
public void lambda$onConnectionStateChanged$89() {
int i = this.spPlayId;
if (i != 0) {
this.soundPool.stop(i);
}
this.spPlayId = this.soundPool.play(this.groupCall != null ? this.spVoiceChatConnecting : this.spConnectingId, 1.0f, 1.0f, 0, -1, 1.0f);
}
public void lambda$playStartRecordSound$91() {
this.soundPool.play(this.spStartRecordId, 0.5f, 0.5f, 0, 0, 1.0f);
}
public void playStartRecordSound() {
Utilities.globalQueue.postRunnable(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$playStartRecordSound$91();
}
});
}
public void lambda$playAllowTalkSound$92() {
this.soundPool.play(this.spAllowTalkId, 0.5f, 0.5f, 0, 0, 1.0f);
}
public void playAllowTalkSound() {
Utilities.globalQueue.postRunnable(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$playAllowTalkSound$92();
}
});
}
@Override
public void onSignalBarCountChanged(final int newCount) {
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$onSignalBarCountChanged$93(newCount);
}
});
}
public void lambda$onSignalBarCountChanged$93(int i) {
this.signalBarCount = i;
for (int i2 = 0; i2 < this.stateListeners.size(); i2++) {
this.stateListeners.get(i2).onSignalBarsCountChanged(i);
}
}
public boolean isBluetoothOn() {
return ((AudioManager) getSystemService("audio")).isBluetoothScoOn();
}
public boolean isBluetoothWillOn() {
return this.needSwitchToBluetoothAfterScoActivates;
}
public boolean isHeadsetPlugged() {
return this.isHeadsetPlugged;
}
private void callEnded() {
if (BuildVars.LOGS_ENABLED) {
FileLog.d("Call " + getCallID() + " ended");
}
this.isCallEnded = true;
if (this.groupCall != null && (!this.playedConnectedSound || this.onDestroyRunnable != null)) {
this.needPlayEndSound = false;
}
AndroidUtilities.runOnUIThread(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$callEnded$94();
}
});
int i = 700;
Utilities.globalQueue.postRunnable(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$callEnded$95();
}
});
Runnable runnable = this.connectingSoundRunnable;
if (runnable != null) {
AndroidUtilities.cancelRunOnUIThread(runnable);
this.connectingSoundRunnable = null;
}
if (this.needPlayEndSound) {
this.playingSound = true;
if (this.groupCall == null) {
Utilities.globalQueue.postRunnable(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$callEnded$96();
}
});
} else {
Utilities.globalQueue.postRunnable(new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$callEnded$97();
}
}, 100L);
i = 500;
}
AndroidUtilities.runOnUIThread(this.afterSoundRunnable, i);
}
Runnable runnable2 = this.timeoutRunnable;
if (runnable2 != null) {
AndroidUtilities.cancelRunOnUIThread(runnable2);
this.timeoutRunnable = null;
}
endConnectionServiceCall(this.needPlayEndSound ? i : 0L);
stopSelf();
}
public void lambda$callEnded$94() {
dispatchStateChanged(11);
}
public void lambda$callEnded$95() {
int i = this.spPlayId;
if (i != 0) {
this.soundPool.stop(i);
this.spPlayId = 0;
}
}
public void lambda$callEnded$96() {
this.soundPool.play(this.spEndId, 1.0f, 1.0f, 0, 0, 1.0f);
}
public void lambda$callEnded$97() {
this.soundPool.play(this.spVoiceChatEndId, 1.0f, 1.0f, 0, 0, 1.0f);
}
private void endConnectionServiceCall(long delay) {
if (USE_CONNECTION_SERVICE) {
Runnable runnable = new Runnable() {
@Override
public final void run() {
VoIPService.this.lambda$endConnectionServiceCall$98();
}
};
if (delay > 0) {
AndroidUtilities.runOnUIThread(runnable, delay);
} else {
runnable.run();
}
}
}
public void lambda$endConnectionServiceCall$98() {
CallConnection callConnection = this.systemCallConnection;
if (callConnection != null) {
int i = this.callDiscardReason;
if (i == 1) {
callConnection.setDisconnected(new DisconnectCause(this.isOutgoing ? 2 : 6));
} else if (i != 2) {
if (i == 3) {
callConnection.setDisconnected(new DisconnectCause(this.isOutgoing ? 4 : 5));
} else if (i == 4) {
callConnection.setDisconnected(new DisconnectCause(7));
} else {
callConnection.setDisconnected(new DisconnectCause(3));
}
} else {
callConnection.setDisconnected(new DisconnectCause(1));
}
this.systemCallConnection.destroy();
this.systemCallConnection = null;
}
}
public boolean isOutgoing() {
return this.isOutgoing;
}
public void handleNotificationAction(Intent intent) {
if ((getPackageName() + ".END_CALL").equals(intent.getAction())) {
stopForeground(true);
hangUp();
return;
}
if ((getPackageName() + ".DECLINE_CALL").equals(intent.getAction())) {
stopForeground(true);
declineIncomingCall(4, null);
return;
}
if ((getPackageName() + ".ANSWER_CALL").equals(intent.getAction())) {
acceptIncomingCallFromNotification();
}
}
public void acceptIncomingCallFromNotification() {
showNotification();
int i = Build.VERSION.SDK_INT;
if (i >= 23 && i < 30 && (checkSelfPermission("android.permission.RECORD_AUDIO") != 0 || (this.privateCall.video && checkSelfPermission("android.permission.CAMERA") != 0))) {
try {
PendingIntent.getActivity(this, 0, new Intent(this, (Class<?>) VoIPPermissionActivity.class).addFlags(268435456), 1107296256).send();
return;
} catch (Exception e) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("Error starting permission activity", e);
return;
}
return;
}
}
acceptIncomingCall();
try {
PendingIntent.getActivity(this, 0, new Intent(this, getUIActivityClass()).setAction("voip"), 33554432).send();
} catch (Exception e2) {
if (BuildVars.LOGS_ENABLED) {
FileLog.e("Error starting incall activity", e2);
}
}
}
public void updateOutputGainControlState() {
if (hasRtmpStream()) {
return;
}
int i = 0;
if (this.tgVoip[0] != null) {
if (!USE_CONNECTION_SERVICE) {
AudioManager audioManager = (AudioManager) getSystemService("audio");
boolean isSpeakerphoneOn = VoipAudioManager.get().isSpeakerphoneOn();
this.tgVoip[0].setAudioOutputGainControlEnabled((!hasEarpiece() || isSpeakerphoneOn || audioManager.isBluetoothScoOn() || this.isHeadsetPlugged) ? false : true);
NativeInstance nativeInstance = this.tgVoip[0];
if (!this.isHeadsetPlugged && (!hasEarpiece() || isSpeakerphoneOn || audioManager.isBluetoothScoOn() || this.isHeadsetPlugged)) {
i = 1;
}
nativeInstance.setEchoCancellationStrength(i);
return;
}
boolean z = this.systemCallConnection.getCallAudioState().getRoute() == 1 ? 1 : 0;
this.tgVoip[0].setAudioOutputGainControlEnabled(z);
this.tgVoip[0].setEchoCancellationStrength(!z);
}
}
public int getAccount() {
return this.currentAccount;
}
public void didReceivedNotification(int id, int account, Object... args) {
if (id == NotificationCenter.appDidLogout) {
callEnded();
}
}
public static boolean isAnyKindOfCallActive() {
return (getSharedInstance() == null || getSharedInstance().getCallState() == 15) ? false : true;
}
private boolean isFinished() {
int i = this.currentState;
return i == 11 || i == 4;
}
public int getRemoteAudioState() {
return this.remoteAudioState;
}
public int getRemoteVideoState() {
return this.remoteVideoState;
}
@TargetApi(26)
private PhoneAccountHandle addAccountToTelecomManager() {
TelecomManager telecomManager = (TelecomManager) getSystemService("telecom");
TLRPC.User currentUser = UserConfig.getInstance(this.currentAccount).getCurrentUser();
PhoneAccountHandle phoneAccountHandle = new PhoneAccountHandle(new ComponentName(this, (Class<?>) TelegramConnectionService.class), BuildConfig.APP_CENTER_HASH + currentUser.id);
telecomManager.registerPhoneAccount(new PhoneAccount.Builder(phoneAccountHandle, ContactsController.formatName(currentUser.first_name, currentUser.last_name)).setCapabilities(2048).setIcon(Icon.createWithResource(this, R.drawable.ic_launcher_dr)).setHighlightColor(Theme.usePlusTheme ? -16738680 : -13851168).addSupportedUriScheme("sip").build());
return phoneAccountHandle;
}
public class CallConnection extends Connection {
public CallConnection() {
setConnectionProperties(128);
setAudioModeIsVoip(true);
}
@Override
public void onCallAudioStateChanged(CallAudioState state) {
if (BuildVars.LOGS_ENABLED) {
FileLog.d("ConnectionService call audio state changed: " + state);
}
Iterator it = VoIPService.this.stateListeners.iterator();
while (it.hasNext()) {
((StateListener) it.next()).onAudioSettingsChanged();
}
}
@Override
public void onDisconnect() {
if (BuildVars.LOGS_ENABLED) {
FileLog.d("ConnectionService onDisconnect");
}
setDisconnected(new DisconnectCause(2));
destroy();
VoIPService.this.systemCallConnection = null;
VoIPService.this.hangUp();
}
@Override
public void onAnswer() {
VoIPService.this.acceptIncomingCallFromNotification();
}
@Override
public void onReject() {
VoIPService.this.needPlayEndSound = false;
VoIPService.this.declineIncomingCall(1, null);
}
@Override
public void onShowIncomingCallUi() {
VoIPService.this.startRinging();
}
@Override
public void onStateChanged(int state) {
super.onStateChanged(state);
if (BuildVars.LOGS_ENABLED) {
FileLog.d("ConnectionService onStateChanged " + Connection.stateToString(state));
}
if (state == 4) {
ContactsController.getInstance(VoIPService.this.currentAccount).deleteConnectionServiceContact();
VoIPService.this.didDeleteConnectionServiceContact = true;
}
}
@Override
public void onCallEvent(String event, Bundle extras) {
super.onCallEvent(event, extras);
if (BuildVars.LOGS_ENABLED) {
FileLog.d("ConnectionService onCallEvent " + event);
}
}
@Override
public void onSilence() {
if (BuildVars.LOGS_ENABLED) {
FileLog.d("onSlience");
}
VoIPService.this.stopRinging();
}
}
}