wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity
90cde83778
gecko/dom/fmradio/FMRadioService.cpp
Nathan Froyd 9c5965b035 Bug 1207245 - part 6 - rename nsRefPtr<T> to RefPtr<T>; r=ehsan; a=Tomcat 
The bulk of this commit was generated with a script, executed at the top
level of a typical source code checkout.  The only non-machine-generated
part was modifying MFBT's moz.build to reflect the new naming.

CLOSED TREE makes big refactorings like this a piece of cake.

 # The main substitution.
find . -name '*.cpp' -o -name '*.cc' -o -name '*.h' -o -name '*.mm' -o -name '*.idl'| \
    xargs perl -p -i -e '
 s/nsRefPtr\.h/RefPtr\.h/g; # handle includes
 s/nsRefPtr ?</RefPtr</g;   # handle declarations and variables
'

 # Handle a special friend declaration in gfx/layers/AtomicRefCountedWithFinalize.h.
perl -p -i -e 's/::nsRefPtr;/::RefPtr;/' gfx/layers/AtomicRefCountedWithFinalize.h

 # Handle nsRefPtr.h itself, a couple places that define constructors
 # from nsRefPtr, and code generators specially.  We do this here, rather
 # than indiscriminantly s/nsRefPtr/RefPtr/, because that would rename
 # things like nsRefPtrHashtable.
perl -p -i -e 's/nsRefPtr/RefPtr/g' \
     mfbt/nsRefPtr.h \
     xpcom/glue/nsCOMPtr.h \
     xpcom/base/OwningNonNull.h \
     ipc/ipdl/ipdl/lower.py \
     ipc/ipdl/ipdl/builtin.py \
     dom/bindings/Codegen.py \
     python/lldbutils/lldbutils/utils.py

 # In our indiscriminate substitution above, we renamed
 # nsRefPtrGetterAddRefs, the class behind getter_AddRefs.  Fix that up.
find . -name '*.cpp' -o -name '*.h' -o -name '*.idl' | \
    xargs perl -p -i -e 's/nsRefPtrGetterAddRefs/RefPtrGetterAddRefs/g'

if [ -d .git ]; then
    git mv mfbt/nsRefPtr.h mfbt/RefPtr.h
else
    hg mv mfbt/nsRefPtr.h mfbt/RefPtr.h
fi
2015-10-18 01:24:48 -04:00

1222 lines
33 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "FMRadioService.h"
#include "mozilla/Hal.h"
#include "mozilla/ClearOnShutdown.h"
#include "nsIAudioManager.h"
#include "AudioManager.h"
#include "nsDOMClassInfo.h"
#include "nsContentUtils.h"
#include "mozilla/LazyIdleThread.h"
#include "mozilla/Preferences.h"
#include "mozilla/dom/FMRadioChild.h"
#include "mozilla/dom/ScriptSettings.h"
#include "nsIObserverService.h"
#include "nsISettingsService.h"
#include "nsJSUtils.h"
#include "mozilla/dom/BindingUtils.h"
#include "mozilla/dom/SettingChangeNotificationBinding.h"
#include "mozilla/DebugOnly.h"
#define TUNE_THREAD_TIMEOUT_MS 5000
#define BAND_87500_108000_kHz 1
#define BAND_76000_108000_kHz 2
#define BAND_76000_90000_kHz 3
#define MOZSETTINGS_CHANGED_ID "mozsettings-changed"
#define SETTING_KEY_AIRPLANEMODE_ENABLED "airplaneMode.enabled"
#define DOM_PARSED_RDS_GROUPS ((0x2 << 30) | (0x3 << 4) | (0x3 << 0))
using mozilla::Preferences;
BEGIN_FMRADIO_NAMESPACE
// static
IFMRadioService*
IFMRadioService::Singleton()
{
if (!XRE_IsParentProcess()) {
return FMRadioChild::Singleton();
} else {
return FMRadioService::Singleton();
}
}
StaticRefPtr<FMRadioService> FMRadioService::sFMRadioService;
FMRadioService::FMRadioService()
: mPendingFrequencyInKHz(0)
, mState(Disabled)
, mHasReadAirplaneModeSetting(false)
, mAirplaneModeEnabled(false)
, mRDSEnabled(false)
, mPendingRequest(nullptr)
, mObserverList(FMRadioEventObserverList())
, mRDSGroupMask(0)
, mLastPI(0)
, mPI(0)
, mPTY(0)
, mPISet(false)
, mPTYSet(false)
, mRDSLock("FMRadioService::mRDSLock")
, mPSNameState(0)
, mRadiotextAB(false)
, mRDSGroupSet(false)
, mPSNameSet(false)
, mRadiotextSet(false)
{
memset(mPSName, 0, sizeof(mPSName));
memset(mRadiotext, 0, sizeof(mRadiotext));
memset(mTempPSName, 0, sizeof(mTempPSName));
memset(mTempRadiotext, 0, sizeof(mTempRadiotext));
// Read power state and frequency from Hal.
mEnabled = hal::IsFMRadioOn();
if (mEnabled) {
mPendingFrequencyInKHz = hal::GetFMRadioFrequency();
SetState(Enabled);
}
switch (Preferences::GetInt("dom.fmradio.band", BAND_87500_108000_kHz)) {
case BAND_76000_90000_kHz:
mUpperBoundInKHz = 90000;
mLowerBoundInKHz = 76000;
break;
case BAND_76000_108000_kHz:
mUpperBoundInKHz = 108000;
mLowerBoundInKHz = 76000;
break;
case BAND_87500_108000_kHz:
default:
mUpperBoundInKHz = 108000;
mLowerBoundInKHz = 87500;
break;
}
mChannelWidthInKHz = Preferences::GetInt("dom.fmradio.channelWidth", 100);
switch (mChannelWidthInKHz) {
case 50:
case 100:
case 200:
break;
default:
NS_WARNING("Invalid channel width specified in dom.fmradio.channelwidth");
mChannelWidthInKHz = 100;
break;
}
mPreemphasis = Preferences::GetInt("dom.fmradio.preemphasis", 50);
switch (mPreemphasis) {
// values in microseconds
case 0:
case 50:
case 75:
break;
default:
NS_WARNING("Invalid preemphasis specified in dom.fmradio.preemphasis");
mPreemphasis = 50;
break;
}
nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
if (obs && NS_FAILED(obs->AddObserver(this,
MOZSETTINGS_CHANGED_ID,
/* useWeak */ false))) {
NS_WARNING("Failed to add settings change observer!");
}
hal::RegisterFMRadioObserver(this);
hal::RegisterFMRadioRDSObserver(this);
}
FMRadioService::~FMRadioService()
{
hal::UnregisterFMRadioRDSObserver(this);
hal::UnregisterFMRadioObserver(this);
}
void
FMRadioService::EnableFMRadio()
{
hal::FMRadioSettings info;
info.upperLimit() = mUpperBoundInKHz;
info.lowerLimit() = mLowerBoundInKHz;
info.spaceType() = mChannelWidthInKHz;
info.preEmphasis() = mPreemphasis;
hal::EnableFMRadio(info);
if (!mTuneThread) {
// hal::FMRadioSeek and hal::SetFMRadioFrequency run on this thread. These
// call ioctls that can stall the main thread, so we run them here.
mTuneThread = new LazyIdleThread(
TUNE_THREAD_TIMEOUT_MS, NS_LITERAL_CSTRING("FM Tuning"));
}
}
/**
* Read the airplane-mode setting, if the airplane-mode is not enabled, we
* enable the FM radio.
*/
class ReadAirplaneModeSettingTask final : public nsISettingsServiceCallback
{
public:
NS_DECL_ISUPPORTS
ReadAirplaneModeSettingTask(RefPtr<FMRadioReplyRunnable> aPendingRequest)
: mPendingRequest(aPendingRequest) { }
NS_IMETHOD
Handle(const nsAString& aName, JS::Handle<JS::Value> aResult)
{
RefPtr<FMRadioService> fmRadioService = FMRadioService::Singleton();
MOZ_ASSERT(mPendingRequest == fmRadioService->mPendingRequest);
fmRadioService->mHasReadAirplaneModeSetting = true;
if (!aResult.isBoolean()) {
// Failed to read the setting value, set the state back to Disabled.
fmRadioService->TransitionState(
ErrorResponse(NS_LITERAL_STRING("Unexpected error")), Disabled);
return NS_OK;
}
fmRadioService->mAirplaneModeEnabled = aResult.toBoolean();
if (!fmRadioService->mAirplaneModeEnabled) {
NS_DispatchToMainThread(NS_NewRunnableFunction(
[fmRadioService] () -> void {
fmRadioService->EnableFMRadio();
}
));
} else {
// Airplane mode is enabled, set the state back to Disabled.
fmRadioService->TransitionState(ErrorResponse(
NS_LITERAL_STRING("Airplane mode currently enabled")), Disabled);
}
return NS_OK;
}
NS_IMETHOD
HandleError(const nsAString& aName)
{
FMRadioService* fmRadioService = FMRadioService::Singleton();
MOZ_ASSERT(mPendingRequest == fmRadioService->mPendingRequest);
fmRadioService->TransitionState(ErrorResponse(
NS_LITERAL_STRING("Unexpected error")), Disabled);
return NS_OK;
}
protected:
~ReadAirplaneModeSettingTask() {}
private:
RefPtr<FMRadioReplyRunnable> mPendingRequest;
};
NS_IMPL_ISUPPORTS(ReadAirplaneModeSettingTask, nsISettingsServiceCallback)
void
FMRadioService::DisableFMRadio()
{
if (mTuneThread) {
mTuneThread->Shutdown();
mTuneThread = nullptr;
}
// Fix Bug 796733. DisableFMRadio should be called before
// SetFmRadioAudioEnabled to prevent the annoying beep sound.
hal::DisableFMRadio();
EnableAudio(false);
};
void
FMRadioService::DispatchFMRadioEventToMainThread(enum FMRadioEventType aType)
{
RefPtr<FMRadioService> self = this;
NS_DispatchToMainThread(NS_NewRunnableFunction(
[self, aType] () -> void {
self->NotifyFMRadioEvent(aType);
}
));
}
void
FMRadioService::TransitionState(const FMRadioResponseType& aResponse,
FMRadioState aState)
{
if (mPendingRequest) {
mPendingRequest->SetReply(aResponse);
NS_DispatchToMainThread(mPendingRequest);
}
SetState(aState);
}
void
FMRadioService::SetState(FMRadioState aState)
{
mState = aState;
mPendingRequest = nullptr;
}
void
FMRadioService::AddObserver(FMRadioEventObserver* aObserver)
{
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
mObserverList.AddObserver(aObserver);
}
void
FMRadioService::RemoveObserver(FMRadioEventObserver* aObserver)
{
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
mObserverList.RemoveObserver(aObserver);
if (mObserverList.Length() == 0)
{
// Turning off the FM radio HW because observer list is empty.
if (hal::IsFMRadioOn()) {
DoDisable();
}
}
}
void
FMRadioService::EnableAudio(bool aAudioEnabled)
{
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
nsCOMPtr<nsIAudioManager> audioManager =
do_GetService("@mozilla.org/telephony/audiomanager;1");
if (!audioManager) {
return;
}
bool audioEnabled;
audioManager->GetFmRadioAudioEnabled(&audioEnabled);
if (audioEnabled != aAudioEnabled) {
audioManager->SetFmRadioAudioEnabled(aAudioEnabled);
}
}
/**
* Round the frequency to match the range of frequency and the channel width. If
* the given frequency is out of range, return 0. For example:
* - lower: 87500KHz, upper: 108000KHz, channel width: 200KHz
* 87.6MHz is rounded to 87700KHz
* 87.58MHz is rounded to 87500KHz
* 87.49MHz is rounded to 87500KHz
* 109MHz is not rounded, 0 will be returned
*
* We take frequency in MHz to prevent precision losing, and return rounded
* value in KHz for Gonk using.
*/
int32_t
FMRadioService::RoundFrequency(double aFrequencyInMHz)
{
double halfChannelWidthInMHz = mChannelWidthInKHz / 1000.0 / 2;
// Make sure 87.49999MHz would be rounded to the lower bound when
// the lower bound is 87500KHz.
if (aFrequencyInMHz < mLowerBoundInKHz / 1000.0 - halfChannelWidthInMHz ||
aFrequencyInMHz > mUpperBoundInKHz / 1000.0 + halfChannelWidthInMHz) {
return 0;
}
int32_t partToBeRounded = round(aFrequencyInMHz * 1000) - mLowerBoundInKHz;
int32_t roundedPart = round(partToBeRounded / (double)mChannelWidthInKHz) *
mChannelWidthInKHz;
return mLowerBoundInKHz + roundedPart;
}
bool
FMRadioService::IsEnabled() const
{
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
return hal::IsFMRadioOn();
}
bool
FMRadioService::IsRDSEnabled() const
{
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
return mRDSEnabled;
}
double
FMRadioService::GetFrequency() const
{
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
if (IsEnabled()) {
int32_t frequencyInKHz = hal::GetFMRadioFrequency();
return frequencyInKHz / 1000.0;
}
return 0;
}
double
FMRadioService::GetFrequencyUpperBound() const
{
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
return mUpperBoundInKHz / 1000.0;
}
double
FMRadioService::GetFrequencyLowerBound() const
{
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
return mLowerBoundInKHz / 1000.0;
}
double
FMRadioService::GetChannelWidth() const
{
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
return mChannelWidthInKHz / 1000.0;
}
Nullable<unsigned short>
FMRadioService::GetPi() const
{
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
if (!mPISet) {
return Nullable<unsigned short>();
}
return Nullable<unsigned short>(mPI);
}
Nullable<uint8_t>
FMRadioService::GetPty() const
{
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
if (!mPTYSet) {
return Nullable<uint8_t>();
}
return Nullable<uint8_t>(mPTY);
}
bool
FMRadioService::GetPs(nsString& aPSName)
{
MutexAutoLock lock(mRDSLock);
if (mPSNameSet) {
aPSName = nsString(mPSName);
}
return mPSNameSet;
}
bool
FMRadioService::GetRt(nsString& aRadiotext)
{
MutexAutoLock lock(mRDSLock);
if (mRadiotextSet) {
aRadiotext = nsString(mRadiotext);
}
return mRadiotextSet;
}
bool
FMRadioService::GetRdsgroup(uint64_t& aRDSGroup)
{
MutexAutoLock lock(mRDSLock);
aRDSGroup = mRDSGroup;
return mRDSGroupSet;
}
void
FMRadioService::Enable(double aFrequencyInMHz,
FMRadioReplyRunnable* aReplyRunnable)
{
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
MOZ_ASSERT(aReplyRunnable);
switch (mState) {
case Seeking:
case Enabled:
aReplyRunnable->SetReply(
ErrorResponse(NS_LITERAL_STRING("FM radio currently enabled")));
NS_DispatchToMainThread(aReplyRunnable);
return;
case Disabling:
aReplyRunnable->SetReply(
ErrorResponse(NS_LITERAL_STRING("FM radio currently disabling")));
NS_DispatchToMainThread(aReplyRunnable);
return;
case Enabling:
aReplyRunnable->SetReply(
ErrorResponse(NS_LITERAL_STRING("FM radio currently enabling")));
NS_DispatchToMainThread(aReplyRunnable);
return;
case Disabled:
break;
}
int32_t roundedFrequency = RoundFrequency(aFrequencyInMHz);
if (!roundedFrequency) {
aReplyRunnable->SetReply(ErrorResponse(
NS_LITERAL_STRING("Frequency is out of range")));
NS_DispatchToMainThread(aReplyRunnable);
return;
}
if (mHasReadAirplaneModeSetting && mAirplaneModeEnabled) {
aReplyRunnable->SetReply(ErrorResponse(
NS_LITERAL_STRING("Airplane mode currently enabled")));
NS_DispatchToMainThread(aReplyRunnable);
return;
}
SetState(Enabling);
// Cache the enable request just in case disable() is called
// while the FM radio HW is being enabled.
mPendingRequest = aReplyRunnable;
// Cache the frequency value, and set it after the FM radio HW is enabled
mPendingFrequencyInKHz = roundedFrequency;
if (!mHasReadAirplaneModeSetting) {
nsCOMPtr<nsISettingsService> settings =
do_GetService("@mozilla.org/settingsService;1");
nsCOMPtr<nsISettingsServiceLock> settingsLock;
nsresult rv = settings->CreateLock(nullptr, getter_AddRefs(settingsLock));
if (NS_FAILED(rv)) {
TransitionState(ErrorResponse(
NS_LITERAL_STRING("Can't create settings lock")), Disabled);
return;
}
RefPtr<ReadAirplaneModeSettingTask> callback =
new ReadAirplaneModeSettingTask(mPendingRequest);
rv = settingsLock->Get(SETTING_KEY_AIRPLANEMODE_ENABLED, callback);
if (NS_FAILED(rv)) {
TransitionState(ErrorResponse(
NS_LITERAL_STRING("Can't get settings lock")), Disabled);
}
return;
}
RefPtr<FMRadioService> self = this;
NS_DispatchToMainThread(NS_NewRunnableFunction(
[self] () -> void {
self->EnableFMRadio();
}
));
}
void
FMRadioService::Disable(FMRadioReplyRunnable* aReplyRunnable)
{
// When airplane-mode is enabled, we will call this function from
// FMRadioService::Observe without passing a FMRadioReplyRunnable,
// so we have to check if |aReplyRunnable| is null before we dispatch it.
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
switch (mState) {
case Disabling:
if (aReplyRunnable) {
aReplyRunnable->SetReply(
ErrorResponse(NS_LITERAL_STRING("FM radio currently disabling")));
NS_DispatchToMainThread(aReplyRunnable);
}
return;
case Disabled:
if (aReplyRunnable) {
aReplyRunnable->SetReply(
ErrorResponse(NS_LITERAL_STRING("FM radio currently disabled")));
NS_DispatchToMainThread(aReplyRunnable);
}
return;
case Enabled:
case Enabling:
case Seeking:
break;
}
RefPtr<FMRadioReplyRunnable> enablingRequest = mPendingRequest;
// If the FM Radio is currently seeking, no fail-to-seek or similar
// event will be fired, execute the seek callback manually.
if (mState == Seeking) {
TransitionState(ErrorResponse(
NS_LITERAL_STRING("Seek action is cancelled")), Disabling);
}
FMRadioState preState = mState;
SetState(Disabling);
mPendingRequest = aReplyRunnable;
if (preState == Enabling) {
// If the radio is currently enabling, we fire the error callback on the
// enable request immediately. When the radio finishes enabling, we'll call
// DoDisable and fire the success callback on the disable request.
enablingRequest->SetReply(
ErrorResponse(NS_LITERAL_STRING("Enable action is cancelled")));
NS_DispatchToMainThread(enablingRequest);
// If we haven't read the airplane mode settings yet we won't enable the
// FM radio HW, so fail the disable request immediately.
if (!mHasReadAirplaneModeSetting) {
SetState(Disabled);
if (aReplyRunnable) {
aReplyRunnable->SetReply(SuccessResponse());
NS_DispatchToMainThread(aReplyRunnable);
}
}
return;
}
DoDisable();
}
void
FMRadioService::DoDisable()
{
// To make such codes work:
// navigator.mozFMRadio.disable();
// navigator.mozFMRadio.ondisabled = function() {
// console.log("We will catch disabled event ");
// };
// we need to call hal::DisableFMRadio() asynchronously. Same reason for
// EnableFMRadio and hal::SetFMRadioFrequency.
RefPtr<FMRadioService> self = this;
NS_DispatchToMainThread(NS_NewRunnableFunction(
[self] () -> void {
self->DisableFMRadio();
}
));
}
void
FMRadioService::SetFrequency(double aFrequencyInMHz,
FMRadioReplyRunnable* aReplyRunnable)
{
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
MOZ_ASSERT(aReplyRunnable);
switch (mState) {
case Disabled:
aReplyRunnable->SetReply(
ErrorResponse(NS_LITERAL_STRING("FM radio currently disabled")));
NS_DispatchToMainThread(aReplyRunnable);
return;
case Enabling:
aReplyRunnable->SetReply(
ErrorResponse(NS_LITERAL_STRING("FM radio currently enabling")));
NS_DispatchToMainThread(aReplyRunnable);
return;
case Disabling:
aReplyRunnable->SetReply(
ErrorResponse(NS_LITERAL_STRING("FM radio currently disabling")));
NS_DispatchToMainThread(aReplyRunnable);
return;
case Seeking:
hal::CancelFMRadioSeek();
TransitionState(ErrorResponse(
NS_LITERAL_STRING("Seek action is cancelled")), Enabled);
break;
case Enabled:
break;
}
int32_t roundedFrequency = RoundFrequency(aFrequencyInMHz);
if (!roundedFrequency) {
aReplyRunnable->SetReply(ErrorResponse(
NS_LITERAL_STRING("Frequency is out of range")));
NS_DispatchToMainThread(aReplyRunnable);
return;
}
mTuneThread->Dispatch(
NS_NewRunnableFunction(
[roundedFrequency] () -> void {
hal::SetFMRadioFrequency(roundedFrequency);
}
), nsIThread::DISPATCH_NORMAL);
aReplyRunnable->SetReply(SuccessResponse());
NS_DispatchToMainThread(aReplyRunnable);
}
void
FMRadioService::Seek(hal::FMRadioSeekDirection aDirection,
FMRadioReplyRunnable* aReplyRunnable)
{
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
MOZ_ASSERT(aReplyRunnable);
switch (mState) {
case Enabling:
aReplyRunnable->SetReply(
ErrorResponse(NS_LITERAL_STRING("FM radio currently enabling")));
NS_DispatchToMainThread(aReplyRunnable);
return;
case Disabled:
aReplyRunnable->SetReply(
ErrorResponse(NS_LITERAL_STRING("FM radio currently disabled")));
NS_DispatchToMainThread(aReplyRunnable);
return;
case Seeking:
aReplyRunnable->SetReply(
ErrorResponse(NS_LITERAL_STRING("FM radio currently seeking")));
NS_DispatchToMainThread(aReplyRunnable);
return;
case Disabling:
aReplyRunnable->SetReply(
ErrorResponse(NS_LITERAL_STRING("FM radio currently disabling")));
NS_DispatchToMainThread(aReplyRunnable);
return;
case Enabled:
break;
}
SetState(Seeking);
mPendingRequest = aReplyRunnable;
mTuneThread->Dispatch(
NS_NewRunnableFunction(
[aDirection] () -> void {
switch (aDirection) {
case hal::FM_RADIO_SEEK_DIRECTION_UP:
case hal::FM_RADIO_SEEK_DIRECTION_DOWN:
hal::FMRadioSeek(aDirection);
break;
default:
MOZ_CRASH();
}
}
), nsIThread::DISPATCH_NORMAL);
}
void
FMRadioService::CancelSeek(FMRadioReplyRunnable* aReplyRunnable)
{
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
MOZ_ASSERT(aReplyRunnable);
// We accept canceling seek request only if it's currently seeking.
if (mState != Seeking) {
aReplyRunnable->SetReply(
ErrorResponse(NS_LITERAL_STRING("FM radio currently not seeking")));
NS_DispatchToMainThread(aReplyRunnable);
return;
}
// Cancel the seek immediately to prevent it from completing.
hal::CancelFMRadioSeek();
TransitionState(
ErrorResponse(NS_LITERAL_STRING("Seek action is cancelled")), Enabled);
aReplyRunnable->SetReply(SuccessResponse());
NS_DispatchToMainThread(aReplyRunnable);
}
void
FMRadioService::SetRDSGroupMask(uint32_t aRDSGroupMask)
{
mRDSGroupMask = aRDSGroupMask;
if (hal::IsFMRadioOn() && mRDSEnabled) {
DebugOnly<bool> enabled = hal::EnableRDS(mRDSGroupMask | DOM_PARSED_RDS_GROUPS);
MOZ_ASSERT(enabled);
}
}
void
FMRadioService::EnableRDS(FMRadioReplyRunnable* aReplyRunnable)
{
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
MOZ_ASSERT(aReplyRunnable);
if (hal::IsFMRadioOn()) {
if (!hal::EnableRDS(mRDSGroupMask | DOM_PARSED_RDS_GROUPS)) {
aReplyRunnable->SetReply(
ErrorResponse(NS_LITERAL_STRING("Could not enable RDS")));
NS_DispatchToMainThread(aReplyRunnable);
return;
}
}
mRDSEnabled = true;
aReplyRunnable->SetReply(SuccessResponse());
NS_DispatchToMainThread(aReplyRunnable);
DispatchFMRadioEventToMainThread(RDSEnabledChanged);
}
void
FMRadioService::DisableRDS(FMRadioReplyRunnable* aReplyRunnable)
{
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
MOZ_ASSERT(aReplyRunnable);
if (hal::IsFMRadioOn()) {
hal::DisableRDS();
}
aReplyRunnable->SetReply(SuccessResponse());
NS_DispatchToMainThread(aReplyRunnable);
if (mRDSEnabled) {
mRDSEnabled = false;
DispatchFMRadioEventToMainThread(RDSEnabledChanged);
}
}
NS_IMETHODIMP
FMRadioService::Observe(nsISupports* aSubject,
const char* aTopic,
const char16_t* aData)
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(sFMRadioService);
if (strcmp(aTopic, MOZSETTINGS_CHANGED_ID) != 0) {
return NS_OK;
}
// The string that we're interested in will be a JSON string looks like:
// {"key":"airplaneMode.enabled","value":true}
RootedDictionary<dom::SettingChangeNotification> setting(nsContentUtils::RootingCx());
if (!WrappedJSToDictionary(aSubject, setting)) {
return NS_OK;
}
if (!setting.mKey.EqualsASCII(SETTING_KEY_AIRPLANEMODE_ENABLED)) {
return NS_OK;
}
if (!setting.mValue.isBoolean()) {
return NS_OK;
}
mAirplaneModeEnabled = setting.mValue.toBoolean();
mHasReadAirplaneModeSetting = true;
// Disable the FM radio HW if Airplane mode is enabled.
if (mAirplaneModeEnabled) {
Disable(nullptr);
}
return NS_OK;
}
void
FMRadioService::NotifyFMRadioEvent(FMRadioEventType aType)
{
mObserverList.Broadcast(aType);
}
void
FMRadioService::Notify(const hal::FMRadioOperationInformation& aInfo)
{
switch (aInfo.operation()) {
case hal::FM_RADIO_OPERATION_ENABLE:
MOZ_ASSERT(hal::IsFMRadioOn());
MOZ_ASSERT(mState == Disabling || mState == Enabling);
// If we're disabling, disable the radio right now.
if (mState == Disabling) {
DoDisable();
return;
}
// Fire success callback on the enable request.
TransitionState(SuccessResponse(), Enabled);
// To make sure the FM app will get the right frequency after the FM
// radio is enabled, we have to set the frequency first.
hal::SetFMRadioFrequency(mPendingFrequencyInKHz);
// Bug 949855: enable audio after the FM radio HW is enabled, to make sure
// 'hw.fm.isAnalog' could be detected as |true| during first time launch.
// This case is for audio output on analog path, i.e. 'ro.moz.fm.noAnalog'
// is not |true|.
EnableAudio(true);
// Update the current frequency without sending the`FrequencyChanged`
// event, to make sure the FM app will get the right frequency when the
// `EnabledChange` event is sent.
mPendingFrequencyInKHz = hal::GetFMRadioFrequency();
UpdatePowerState();
// The frequency was changed from '0' to some meaningful number, so we
// should send the `FrequencyChanged` event manually.
NotifyFMRadioEvent(FrequencyChanged);
if (mRDSEnabled) {
mRDSEnabled = hal::EnableRDS(mRDSGroupMask | DOM_PARSED_RDS_GROUPS);
if (!mRDSEnabled) {
NotifyFMRadioEvent(RDSEnabledChanged);
}
}
break;
case hal::FM_RADIO_OPERATION_DISABLE:
MOZ_ASSERT(mState == Disabling);
mPISet = false;
mPTYSet = false;
memset(mPSName, 0, sizeof(mPSName));
memset(mRadiotext, 0, sizeof(mRadiotext));
TransitionState(SuccessResponse(), Disabled);
UpdatePowerState();
break;
case hal::FM_RADIO_OPERATION_SEEK:
// Seek action might be cancelled by SetFrequency(), we need to check if
// the current state is Seeking.
if (mState == Seeking) {
TransitionState(SuccessResponse(), Enabled);
}
UpdateFrequency();
break;
case hal::FM_RADIO_OPERATION_TUNE:
UpdateFrequency();
break;
default:
MOZ_CRASH();
}
}
/* This is defined by the RDS standard */
static const uint16_t sRDSToUnicodeMap[256] = {
// The lower half differs from ASCII in 0x1F, 0x24, 0x5E, 0x7E
// Most control characters are replaced with 0x20 (space)
// 0x0-
0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
0x0020, 0x0009, 0x000A, 0x000B, 0x0020, 0x00D0, 0x0020, 0x0020,
// 0x1-
0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
0x0020, 0x0020, 0x0020, 0x001B, 0x0020, 0x0020, 0x0020, 0x00AD,
// 0x2-
0x0020, 0x0021, 0x0022, 0x0023, 0x00A4, 0x0025, 0x0026, 0x0027,
0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
// 0x3-
0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
// 0x4-
0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
// 0x5-
0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x2015, 0x005F,
// 0x6-
0x2551, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
// 0x7-
0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x00AF, 0x007F,
// 0x8-
0x00E1, 0x00E0, 0x00E9, 0x00E8, 0x00ED, 0x00EC, 0x00F3, 0x00F2,
0x00FA, 0x00F9, 0x00D1, 0x00C7, 0x015E, 0x00DF, 0x00A1, 0x0132,
// 0x9-
0x00E2, 0x00E4, 0x00EA, 0x00EB, 0x00EE, 0x00EF, 0x00F4, 0x00F6,
0x00FB, 0x00FC, 0x00F1, 0x00E7, 0x015F, 0x011F, 0x0131, 0x0133,
// 0xA-
0x00AA, 0x03B1, 0x00A9, 0x2030, 0x011E, 0x011B, 0x0148, 0x0151,
0x03C0, 0x20AC, 0x00A3, 0x0024, 0x2190, 0x2191, 0x2192, 0x2193,
// 0xB-
0x00BA, 0x00B9, 0x00B2, 0x00B3, 0x00B1, 0x0130, 0x0144, 0x0171,
0x03BC, 0x00BF, 0x00F7, 0x00B0, 0x00BC, 0x00BD, 0x00BE, 0x00A7,
// 0xC-
0x00C1, 0x00C0, 0x00C9, 0x00C8, 0x00CD, 0x00CC, 0x00D3, 0x00D2,
0x00DA, 0x00D9, 0x0158, 0x010C, 0x0160, 0x017D, 0x00D0, 0x013F,
// 0xD-
0x00C2, 0x00C4, 0x00CA, 0x00CB, 0x00CE, 0x00CF, 0x00D4, 0x00D6,
0x00DB, 0x00DC, 0x0159, 0x010D, 0x0161, 0x017E, 0x0111, 0x0140,
// 0xE-
0x00C3, 0x00C5, 0x00C6, 0x0152, 0x0177, 0x00DD, 0x00D5, 0x00D8,
0x00DE, 0x014A, 0x0154, 0x0106, 0x015A, 0x0179, 0x0166, 0x00F0,
// 0xF-
0x00E3, 0x00E5, 0x00E6, 0x0153, 0x0175, 0x00FD, 0x00F5, 0x00F8,
0x00FE, 0x014B, 0x0155, 0x0107, 0x015B, 0x017A, 0x0167, 0x0020,
};
void
FMRadioService::Notify(const hal::FMRadioRDSGroup& aRDSGroup)
{
uint16_t blocks[4];
blocks[0] = aRDSGroup.blockA();
blocks[1] = aRDSGroup.blockB();
blocks[2] = aRDSGroup.blockC();
blocks[3] = aRDSGroup.blockD();
/* Bit 11 in block B determines whether this is a type B group. */
uint16_t lastPI = blocks[1] & (1 << 11) ? blocks[2] : mLastPI;
/* Update PI if it's not set or if we get two PI with the new value. */
if ((mPI != blocks[0] && lastPI == blocks[0]) || !mPISet) {
mPI = blocks[0];
if (!mPISet) {
mPSNameState = 0;
mRadiotextState = 0;
memset(mTempPSName, 0, sizeof(mTempPSName));
memset(mTempRadiotext, 0, sizeof(mTempRadiotext));
}
mPISet = true;
DispatchFMRadioEventToMainThread(PIChanged);
}
mLastPI = blocks[0];
/* PTY is also updated using the same logic as PI */
uint16_t pty = (blocks[1] >> 5) & 0x1F;
if ((mPTY != pty && pty == mLastPTY) || !mPTYSet) {
mPTY = pty;
mPTYSet = true;
DispatchFMRadioEventToMainThread(PTYChanged);
}
mLastPTY = pty;
uint16_t grouptype = blocks[1] >> 11;
switch (grouptype) {
case 0: // 0a
case 1: // 0b
{
uint16_t segmentAddr = (blocks[1] & 0x3);
// mPSNameState is a bitmask that lets us ensure all segments
// are received before updating the PS name.
if (!segmentAddr) {
mPSNameState = 1;
} else {
mPSNameState |= 1 << segmentAddr;
}
uint16_t offset = segmentAddr << 1;
mTempPSName[offset] = sRDSToUnicodeMap[blocks[3] >> 8];
mTempPSName[offset + 1] = sRDSToUnicodeMap[blocks[3] & 0xFF];
if (mPSNameState != 0xF) {
break;
}
mPSNameState = 0;
if (memcmp(mTempPSName, mPSName, sizeof(mTempPSName))) {
MutexAutoLock lock(mRDSLock);
mPSNameSet = true;
memcpy(mPSName, mTempPSName, sizeof(mTempPSName));
DispatchFMRadioEventToMainThread(PSChanged);
}
break;
}
case 4: // 2a Radiotext
{
uint16_t segmentAddr = (blocks[1] & 0xF);
bool textAB = blocks[1] & (1 << 5);
if (textAB != mRadiotextAB) {
mRadiotextState = 0;
memset(mTempRadiotext, 0, sizeof(mTempRadiotext));
mRadiotextAB = textAB;
MutexAutoLock lock(mRDSLock);
memset(mRadiotext, 0, sizeof(mRadiotext));
DispatchFMRadioEventToMainThread(RadiotextChanged);
}
// mRadiotextState is a bitmask that lets us ensure all segments
// are received before updating the radiotext.
if (!segmentAddr) {
mRadiotextState = 1;
} else {
mRadiotextState |= 1 << segmentAddr;
}
uint8_t segment[4];
segment[0] = blocks[2] >> 8;
segment[1] = blocks[2] & 0xFF;
segment[2] = blocks[3] >> 8;
segment[3] = blocks[3] & 0xFF;
uint16_t offset = segmentAddr << 2;
bool done = false;
for (int i = 0; i < 4; i++) {
if (segment[i] == '\r') {
mTempRadiotext[offset++] = 0;
done = true;
} else {
mTempRadiotext[offset++] = sRDSToUnicodeMap[segment[i]];
}
}
if (offset == 64) {
done = true;
}
if (!done ||
(mRadiotextState + 1) != (1 << ((blocks[1] & 0xF) + 1)) ||
!memcmp(mTempRadiotext, mRadiotext, sizeof(mTempRadiotext))) {
break;
}
MutexAutoLock lock(mRDSLock);
mRadiotextSet = true;
memcpy(mRadiotext, mTempRadiotext, sizeof(mTempRadiotext));
DispatchFMRadioEventToMainThread(RadiotextChanged);
break;
}
case 5: // 2b Radiotext
{
uint16_t segmentAddr = (blocks[1] & 0xF);
bool textAB = blocks[1] & (1 << 5);
if (textAB != mRadiotextAB) {
mRadiotextState = 0;
memset(mTempRadiotext, 0, sizeof(mTempRadiotext));
mRadiotextAB = textAB;
MutexAutoLock lock(mRDSLock);
memset(mRadiotext, 0, sizeof(mRadiotext));
DispatchFMRadioEventToMainThread(RadiotextChanged);
}
if (!segmentAddr) {
mRadiotextState = 1;
} else {
mRadiotextState |= 1 << segmentAddr;
}
uint8_t segment[2];
segment[0] = blocks[3] >> 8;
segment[1] = blocks[3] & 0xFF;
uint16_t offset = segmentAddr << 1;
bool done = false;
for (int i = 0; i < 2; i++) {
if (segment[i] == '\r') {
mTempRadiotext[offset++] = 0;
done = true;
} else {
mTempRadiotext[offset++] = sRDSToUnicodeMap[segment[i]];
}
}
if (offset == 32) {
done = true;
}
if (!done ||
(mRadiotextState + 1) != (1 << ((blocks[1] & 0xF) + 1)) ||
!memcmp(mTempRadiotext, mRadiotext, sizeof(mTempRadiotext))) {
break;
}
MutexAutoLock lock(mRDSLock);
mRadiotextSet = true;
memcpy(mRadiotext, mTempRadiotext, sizeof(mTempRadiotext));
DispatchFMRadioEventToMainThread(RadiotextChanged);
break;
}
case 31: // 15b Fast Tuning and Switching
{
uint16_t secondPty = (blocks[3] >> 5) & 0x1F;
if (pty == mPTY || pty != secondPty) {
break;
}
mPTY = pty;
DispatchFMRadioEventToMainThread(PTYChanged);
break;
}
}
// Only notify users of raw RDS groups that they're interested in.
// We always receive DOM_PARSED_RDS_GROUPS when RDS is enabled.
if (!(mRDSGroupMask & (1 << grouptype))) {
return;
}
uint64_t newgroup = blocks[0];
newgroup <<= 16;
newgroup |= blocks[1];
newgroup <<= 16;
newgroup |= blocks[2];
newgroup <<= 16;
newgroup |= blocks[3];
MutexAutoLock lock(mRDSLock);
mRDSGroup = newgroup;
mRDSGroupSet = true;
DispatchFMRadioEventToMainThread(NewRDSGroup);
}
void
FMRadioService::UpdatePowerState()
{
bool enabled = hal::IsFMRadioOn();
if (enabled != mEnabled) {
mEnabled = enabled;
NotifyFMRadioEvent(EnabledChanged);
}
}
void
FMRadioService::UpdateFrequency()
{
int32_t frequency = hal::GetFMRadioFrequency();
if (mPendingFrequencyInKHz != frequency) {
mPendingFrequencyInKHz = frequency;
NotifyFMRadioEvent(FrequencyChanged);
mPISet = false;
mPTYSet = false;
memset(mPSName, 0, sizeof(mPSName));
memset(mRadiotext, 0, sizeof(mRadiotext));
mRDSGroupSet = false;
mPSNameSet = false;
mRadiotextSet = false;
}
}
// static
FMRadioService*
FMRadioService::Singleton()
{
MOZ_ASSERT(XRE_IsParentProcess());
MOZ_ASSERT(NS_IsMainThread());
if (!sFMRadioService) {
sFMRadioService = new FMRadioService();
ClearOnShutdown(&sFMRadioService);
}
return sFMRadioService;
}
NS_IMPL_ISUPPORTS(FMRadioService, nsIObserver)
END_FMRADIO_NAMESPACE
Reference in New Issue View Git Blame Copy Permalink