public bool ReleaseLock(string lock_type = "screenDim")
{
lock (wakeLocks)
{
if (!wakeLocks.ContainsKey(lock_type))
{
return(false);
}
switch (lock_type)
{
case "screenDim":
case "partial":
case "proximityScreenOff":
PowerManager.WakeLock pm_lock = (PowerManager.WakeLock)wakeLocks[lock_type];
pm_lock.Release();
break;
case "wifi":
WifiManager.WifiLock wm_lock = (WifiManager.WifiLock)wakeLocks[lock_type];
wm_lock.Release();
break;
}
wakeLocks.Remove(lock_type);
return(true);
}
}
/// <summary>
/// Constructor
/// </summary>
public NetworkController()
{
wifiManager = (WifiManager)MainActivity.Context.GetSystemService(MainActivity.Wifi);
connectivityManager = (ConnectivityManager)MainActivity.Context.GetSystemService(MainActivity.Connectivity);
wifiLock = wifiManager.CreateWifiLock(WifiMode.Full, "Wifi lock");
RefreshNetworkInfo();
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
TabLayoutResource = Resource.Layout.Tabbar;
ToolbarResource = Resource.Layout.Toolbar;
MessagingCenter.Subscribe <ViewModels.StreamPageViewModel>(this, "landscape", sender =>
{
LockRotation(Orientation.Horizontal);
});
MessagingCenter.Subscribe <ViewModels.StreamPageViewModel>(this, "portrait", sender =>
{
LockRotation(Orientation.Vertical);
});
Popup.Init(this, savedInstanceState);
Forms.Init(this, savedInstanceState);
AuthenticationConfiguration.Init(this, savedInstanceState);
if (ApplicationContext.GetSystemService(WifiService) is WifiManager wifiManager)
{
WifiLock = wifiManager.CreateWifiLock(WifiMode.FullHighPerf, WifiTag);
WifiLock.SetReferenceCounted(false);
WifiLock.Acquire();
}
LoadApplication(new App());
}
/// <summary>
/// Lock the wifi so we can still stream under lock screen
/// </summary>
private void AquireWifiLock()
{
if (_wifiLock == null)
{
_wifiLock = _wifiManager.CreateWifiLock(WifiMode.Full, "xamarin_wifi_lock");
}
_wifiLock.Acquire();
}
/// <summary>
/// Lock the wifi so we can still stream under lock screen
/// </summary>
public static void AquireWifiLock()
{
if (WifiLock == null)
{
WifiLock = WifiManager.CreateWifiLock(Android.Net.WifiMode.Full, "bitchute_wifi_lock");
}
WifiLock.Acquire();
}
private void AquireWifiLock()
{
if (wifiLock == null)
{
wifiLock = wifiManager.CreateWifiLock(WifiMode.Full, "wifi_lock");
}
wifiLock.Acquire();
}
/// <summary>
/// Lock the wifi so we can still stream under lock screen
/// </summary>
public void AquireWifiLock()
{
if (wifiLock == null)
{
wifiLock = wifiManager.CreateWifiLock(WifiMode.Full, "xamarin_wifi_lock");
}
wifiLock.Acquire();
}
private void ReleaseWifiLock()
{
if (WifiLock != null)
{
WifiLock.Release();
WifiLock = null;
}
}
/// <summary>
/// Lock the wifi so we can still stream under lock screen
/// </summary>
private void AquireWifiLock()
{
if (this.wifiLock == null)
{
this.wifiLock = this.wifiManager.CreateWifiLock(WifiMode.Full, "fildo_wifi_lock");
}
this.wifiLock.Acquire();
}
IntentFilter audioNoisyIntentFilter; // = new IntentFilter(AudioManager.ActionAudioBecomingNoisy);
public MediaPlayerPlayer(Context context)
{
Context = context;
//NoisyAudioReciever = new MediaPlayerPlayer.NoisyReciever();
//audioNoisyIntentFilter = new IntentFilter(AudioManager.ActionAudioBecomingNoisy);;
audioManager = (AudioManager)context.GetSystemService(Context.AudioService);
WifiLock = ((WifiManager)context.GetSystemService(Context.WifiService)).CreateWifiLock(WifiMode.Full, "gMusic_lock");
state = PlaybackStateCompat.StateNone;
}
/// <summary>
/// Lock the wifi so we can still stream under lock screen
/// </summary>
private void AquireWifiLock()
{
if (wifiLock == null)
{
wifiLock = wifiManager.CreateWifiLock(global::Android.Net.WifiMode.Full, nameof(AudioPlayer));
}
wifiLock.Acquire();
}
/// <summary>
/// This will release the wifi lock if it is no longer needed
/// </summary>
private static void ReleaseWifiLock()
{
if (WifiLock == null)
{
return;
}
WifiLock.Release();
WifiLock = null;
}
/// <summary>
/// This will release the wifi lock if it is no longer needed
/// </summary>
private void ReleaseWifiLock()
{
if (this.wifiLock == null)
{
return;
}
this.wifiLock.Release();
this.wifiLock = null;
}
/// <summary>
/// This will release the wifi lock if it is no longer needed
/// </summary>
private void ReleaseWifiLock()
{
if (wifiLock == null || !wifiLock.IsHeld)
{
return;
}
wifiLock.Release();
wifiLock = null;
}
/// <summary>
/// This will release the wifi lock if it is no longer needed
/// </summary>
private void ReleaseWifiLock()
{
if (_wifiLock == null)
{
return;
}
_wifiLock.Release();
_wifiLock = null;
}
// TODO: Open M3U, parse and save it
public override void OnCreate()
{
base.OnCreate();
currentState = MediaStates.Zero;
am = GetSystemService(Context.AudioService) as AudioManager;
am.RegisterMediaButtonEventReceiver(mediaComponent);
wifiLock = ((WifiManager)GetSystemService(Context.WifiService)).CreateWifiLock(Android.Net.WifiMode.Full, "myServiceLock");
mediaComponent = new ComponentName(ApplicationContext, new StreamBroadcastReceiver().Class);
}
public RadioStationServiceLock(Context context)
{
_wifiManager = (WifiManager)context.GetSystemService(Context.WifiService);
_powerManager = (PowerManager)context.GetSystemService(Context.PowerService);
_wifiLock = _wifiManager.CreateWifiLock(WifiMode.Full, "wzxv.app");
_wifiLock.Acquire();
_powerWakeLock = _powerManager.NewWakeLock(WakeLockFlags.Partial, "wzxv.app");
_powerWakeLock.Acquire();
}
public void Release()
{
if (_wifiLock != null)
{
_wifiLock.Release();
_wifiLock = null;
}
if (_powerWakeLock != null)
{
_powerWakeLock.Release();
_powerWakeLock = null;
}
}
public override void OnCreate()
{
base.OnCreate();
Log.Debug(logTag, "OnCreate called in the Location Service");
var pm = (PowerManager)GetSystemService(Context.PowerService);
_mWakeLock = pm.NewWakeLock(WakeLockFlags.Partial, "PartialWakeLockTag");
_mWakeLock.Acquire();
var wf = (WifiManager)GetSystemService(Context.WifiService);
_wifiLock = wf.CreateWifiLock(Android.Net.WifiMode.Full, "WifiLockTag");
_wifiLock.Acquire();
}
/// <summary>
/// This will release the wifi lock if it is no longer needed
/// </summary>
public void ReleaseWifiLock()
{
try
{
if (wifiLock == null || !wifiLock.IsHeld)
{
return;
}
wifiLock.Release();
}
catch (Java.Lang.RuntimeException ex)
{
Console.WriteLine(ex.Message);
}
wifiLock = null;
}
public void InitMusicPlayer()
{
_appSettingsHelper = new AppSettingsHelper();
_player = new MediaPlayer();
_wifiLock = ((WifiManager)GetSystemService(WifiService)).CreateWifiLock(WifiMode.Full, "playerLock");
_player.SetWakeMode(ApplicationContext, WakeLockFlags.Partial);
_player.SetAudioStreamType(Stream.Music);
_player.SetOnPreparedListener(this);
_player.SetOnCompletionListener(this);
_player.SetOnErrorListener(this);
_audioManager = (AudioManager)GetSystemService(AudioService);
_mediaButtonReceiverComponent = new ComponentName(ApplicationContext,
Class.FromType(typeof(HeadsetButtonsReceiver)));
_audioManager.RegisterMediaButtonEventReceiver(_mediaButtonReceiverComponent);
}
public MusicPlayer(MusicService service, MusicProvider musicProvider)
{
MusicPlayerState = PlaybackStateCode.None;
_audioFocusState = AudioFocusState.NoFocusAndNoHide;
_musicService = service;
_musicProvider = musicProvider;
_audioManager = (AudioManager)service.GetSystemService(Context.AudioService);
_wifiLock = ((WifiManager)service.GetSystemService(Context.WifiService))
.CreateWifiLock(WifiMode.Full, "mywifilock");
if (_mediaPlayer == null)
{
_mediaPlayer = new MediaPlayer();
_mediaPlayer.SetWakeMode(_musicService.ApplicationContext,
Android.OS.WakeLockFlags.Partial);
_mediaPlayer.SetOnPreparedListener(this);
_mediaPlayer.SetOnCompletionListener(this);
_mediaPlayer.SetOnErrorListener(this);
_mediaPlayer.SetOnSeekCompleteListener(this);
}
}
public Playback(MusicService service, MusicProvider musicProvider)
{
this.service = service;
this.musicProvider = musicProvider;
audioManager = (AudioManager)service.GetSystemService(Context.AudioService);
wifiLock = ((WifiManager)service.GetSystemService(Context.WifiService))
.CreateWifiLock(WifiMode.Full, "sample_lock");
mAudioNoisyReceiver.OnReceiveImpl = (context, intent) => {
if (AudioManager.ActionAudioBecomingNoisy == intent.Action)
{
LogHelper.Debug(Tag, "Headphones disconnected.");
if (IsPlaying)
{
var i = new Intent(context, typeof(MusicService));
i.SetAction(MusicService.ActionCmd);
i.PutExtra(MusicService.CmdName, MusicService.CmdPause);
service.StartService(i);
}
}
};
}
private void _Start(string host, int port)
{
try
{
if (m_Running)
{
return;
}
Android.OS.Process.SetThreadPriority(ThreadPriority.UrgentAudio);
PowerManager powerManager = (PowerManager)GetSystemService(PowerService);
m_WakeLock =
powerManager.NewWakeLock(WakeLockFlags.Partial,
"snapdotnet:SnapcastPartialWakeLock");
m_WakeLock.Acquire();
WifiManager wifiManager = (WifiManager)GetSystemService(WifiService);
m_WifiLock = wifiManager.CreateWifiLock(WifiMode.FullHighPerf, "snapdotnet:SnapcastWifiWakeLock");
m_WifiLock.Acquire();
m_Host = host;
m_Port = port;
_StartProcess();
}
catch (Exception e)
{
e.PrintStackTrace();
if (m_SnapclientListener != null)
{
m_SnapclientListener.OnError(this, e.Message, e);
}
_Stop();
}
}
public override void OnCreate()
{
base.OnCreate();
this.disposable = new CompositeDisposable();
this.wakeLock = PowerManager.FromContext(this).NewWakeLock(WakeLockFlags.Partial, "espera-wake-lock");
this.wifiLock = WifiManager.FromContext(this).CreateWifiLock(WifiMode.Full, "espera-wifi-lock");
NetworkMessenger.Instance.WhenAnyValue(x => x.IsConnected).Where(x => x)
.Subscribe(x => this.NotifyNetworkMessengerConnected())
.DisposeWith(this.disposable);
NetworkMessenger.Instance.Disconnected.Subscribe(x => this.NotifyNetworkMessengerDisconnected())
.DisposeWith(this.disposable);
var userSettings = Locator.Current.GetService <UserSettings>();
NetworkMessenger.Instance.WhenAnyValue(x => x.IsConnected).SampleAndCombineLatest(userSettings
.WhenAnyValue(x => x.Port).DistinctUntilChanged(), (connected, _) => connected)
.Where(x => x)
.Subscribe(x => NetworkMessenger.Instance.Disconnect())
.DisposeWith(this.disposable);
AndroidVolumeRequests.Instance.VolumeDown.CombineLatest(NetworkMessenger.Instance.WhenAnyValue(x => x.IsConnected),
NetworkMessenger.Instance.WhenAnyValue(x => x.AccessPermission),
(_, connected, permission) => connected && permission == NetworkAccessPermission.Admin)
.Where(x => x)
.SelectMany(_ => NetworkMessenger.Instance.GetVolume().ToObservable().SwallowNetworkExceptions())
.Where(currentVolume => currentVolume > 0)
.Select(currentVolume => Math.Max(currentVolume - 0.1f, 0))
.Select(volume => NetworkMessenger.Instance.SetVolume(volume).ToObservable().SwallowNetworkExceptions())
.Concat()
.Subscribe()
.DisposeWith(this.disposable);
AndroidVolumeRequests.Instance.VolumeUp.CombineLatest(NetworkMessenger.Instance.WhenAnyValue(x => x.IsConnected),
NetworkMessenger.Instance.WhenAnyValue(x => x.AccessPermission),
(_, connected, permission) => connected && permission == NetworkAccessPermission.Admin)
.Where(x => x)
.SelectMany(_ => NetworkMessenger.Instance.GetVolume().ToObservable().SwallowNetworkExceptions())
.Where(currentVolume => currentVolume < 1)
.Select(currentVolume => Math.Min(currentVolume + 0.1f, 1))
.Select(volume => NetworkMessenger.Instance.SetVolume(volume).ToObservable().SwallowNetworkExceptions())
.Concat()
.Subscribe()
.DisposeWith(this.disposable);
var androidSettings = Locator.Current.GetService <AndroidSettings>();
NetworkMessenger.Instance.WhenAnyValue(x => x.IsConnected).CombineLatest(androidSettings.WhenAnyValue(x => x.SaveEnergy), (connected, saveEnergy) =>
{
if (connected && !saveEnergy)
{
this.wakeLock.Acquire();
this.wifiLock.Acquire();
}
else if (!connected)
{
this.ReleaseWakeLocks();
}
return(Unit.Default);
})
.Subscribe()
.DisposeWith(this.disposable);
}
/// <summary>
/// Constructor
/// </summary>
public NetworkController()
{
wifiManager = (WifiManager)Application.Context.GetSystemService(Android.Content.Context.WifiService);
connectivityManager = (ConnectivityManager)Application.Context.GetSystemService(Android.Content.Context.ConnectivityService);
wifiLock = wifiManager.CreateWifiLock(WifiMode.Full, "Wifi lock");
}
/// <summary>
/// This will release the wifi lock if it is no longer needed
/// </summary>
private void ReleaseWifiLock()
{
wifiLock?.Release();
wifiLock = null;
}
protected override void OnCreate(Bundle savedInstanceState)
{
AppCenter.Start("b17f9c9d-e90c-488f-8c4b-92ef3e305c0d", typeof(Analytics), typeof(Distribute));
var versionInfo = Application.Context.ApplicationContext?.PackageManager?.GetPackageInfo(Application.Context.ApplicationContext.PackageName, 0);
//var username = System.Security.Principal.WindowsIdentity.GetCurrent();
SentryXamarin.Init(o =>
{
o.AddXamarinFormsIntegration();
o.Dsn = "https://[email protected]/5390642";
o.Release = $"TacControl@{versionInfo?.VersionName}:{versionInfo?.LongVersionCode}";
o.Environment = //username == "Dedmen-PC\\dedmen" ? "Dev" :
"Alpha";
});
WifiManager wifiMgr = (WifiManager)ApplicationContext.GetSystemService(Context.WifiService);
wifiLock = wifiMgr.CreateWifiLock(WifiMode.Full, "TacControl-udp");
wifiLock.SetReferenceCounted(true);
wifiLock.Acquire();
castLock = wifiMgr.CreateMulticastLock("TacControl-udp");
castLock.SetReferenceCounted(true);
castLock.Acquire();
ConnectivityManager conMgr = (ConnectivityManager)ApplicationContext.GetSystemService(Context.ConnectivityService);
var stuff = conMgr.GetAllNetworks();
var wifiNet = stuff.FirstOrDefault(x => conMgr.GetNetworkInfo(x).Type == ConnectivityType.Wifi);
if (wifiNet != null)
{
var res = conMgr.BindProcessToNetwork(wifiNet);
var info = conMgr.GetNetworkInfo(wifiNet);
var connInfo = wifiMgr.ConnectionInfo;
}
//Networking.ConnectionInfo
TabLayoutResource = Resource.Layout.Tabbar;
ToolbarResource = Resource.Layout.Toolbar;
base.OnCreate(savedInstanceState);
Xamarin.Essentials.Platform.Init(this, savedInstanceState);
global::Xamarin.Forms.Forms.Init(this, savedInstanceState);
Android.Views.Window window = Window;
window.AddFlags(WindowManagerFlags.KeepScreenOn);
window.AddFlags(WindowManagerFlags.Fullscreen);
LoadApplication(new App((action) =>
{
TaskCompletionSource <object> tcs = new TaskCompletionSource <object>();
bool isMain = MainThread.IsMainThread;
RunOnUiThread(() =>
{
try
{
action();
tcs.SetResult(null);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
});
return(tcs.Task);
}));
}
