PacketDirection getPacketDirection(IndicatorState state);
RssiState getRssiState(IndicatorState state);
bool getRoamingState(IndicatorState state);
-
+ int getBatteryLevel(IndicatorState state);
+ BatteryState getBatteryState(IndicatorState state);
}
#endif // __CALLUI_MODEL_INDICATOR_STATE_H__
FLIGHT_MODE
};
+ enum class BatteryState {
+ NORMAL = 0,
+ CHARGING,
+ CHARGING_PROBLEM,
+ UNKNOWN
+ };
+
enum class IndicatorProperty {
NW_CONNECTION = 0,
RSSI,
--- /dev/null
+/*
+ * Copyright 2017 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "BatteryStateSource.h"
+
+#include "common.h"
+
+namespace callui {
+
+ using namespace ucl;
+
+ BatteryStateSource::Bits::Bits():
+ property(convertEnumValueToInt(IndicatorProperty::BATTERY)),
+ chargeValue(0),
+ chargingState(convertEnumValueToInt(BatteryState::NORMAL))
+ {
+ }
+
+ BatteryStateSource::Bits::Bits(const IndicatorState &state):
+ value(state.value)
+ {
+ if (property != convertEnumValueToInt(IndicatorProperty::BATTERY)) {
+ ELOG("State of incorrect property type [%d]", property);
+ *this = {};
+ }
+ }
+
+ BatteryStateSource::BatteryStateSource()
+ {
+ }
+
+ BatteryStateSource::~BatteryStateSource()
+ {
+ delSysStateCallbacks();
+ }
+
+ BatteryStateSourceSRef BatteryStateSource::newInstance()
+ {
+ auto result = makeShared<BatteryStateSource>();
+ FAIL_RETURN_VALUE(result->prepare(), {}, "result->prepare() failed!");
+ return result;
+ }
+
+ Result BatteryStateSource::prepare()
+ {
+ FAIL_RETURN(addSysStateCallbacks(), "addSysStateCallbacks() failed!");
+
+ updateBatteryState();
+
+ return RES_OK;
+ }
+
+ bool BatteryStateSource::updateChargingStateBits(BatteryState state)
+ {
+ int stateInt = convertEnumValueToInt(state);
+ if (stateInt != m_bits.chargingState) {
+ m_bits.chargingState = stateInt;
+ return true;
+ }
+ return false;
+ }
+
+ bool BatteryStateSource::updateChargeLevelBits(int value)
+ {
+ if (value != m_bits.chargeValue) {
+ m_bits.chargeValue = value;
+ return true;
+ }
+ return false;
+ }
+
+ int BatteryStateSource::getCurChargeLevel() const
+ {
+ int capacity = 0;
+ if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CAPACITY, &capacity) == 0) {
+ return capacity;
+ }
+ ELOG("Get battery capacity failed!");
+ return -1;
+ }
+
+ BatteryState BatteryStateSource::getCurChargingState() const
+ {
+ int isCharged = 0;
+ if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, &isCharged) == 0) {
+ switch (isCharged) {
+ case -1: return BatteryState::CHARGING_PROBLEM;
+ case 1: return BatteryState::CHARGING;
+ default: return BatteryState::NORMAL;
+ }
+ }
+ ELOG("Get battery charging status failed!");
+ return BatteryState::NORMAL;
+ }
+
+ bool BatteryStateSource::updateBatteryState()
+ {
+ int chargeLevel = getCurChargeLevel();
+ BatteryState state = getCurChargingState();
+
+ if (chargeLevel < 0) {
+ chargeLevel = 0;
+ if (state == BatteryState::NORMAL) {
+ state = BatteryState::UNKNOWN;
+ }
+ }
+
+ bool wasUpdated = updateChargingStateBits(state);
+ if (updateChargeLevelBits(chargeLevel)) {
+ wasUpdated = true;
+ }
+ return wasUpdated;
+ }
+
+ void BatteryStateSource::onBatteryStateChangedCb(keynode_t *node)
+ {
+ if (updateBatteryState() && m_handler) {
+ m_handler();
+ }
+ }
+
+ Result BatteryStateSource::addSysStateCallbacks()
+ {
+ int res = vconf_notify_key_changed(VCONFKEY_SYSMAN_CHARGER_STATUS,
+ CALLBACK_B(BatteryStateSource::onBatteryStateChangedCb), this);
+ if (res != 0) {
+ LOG_RETURN(RES_FAIL, "vconf_notify_key_changed() failed");
+ }
+
+ res = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW,
+ CALLBACK_B(BatteryStateSource::onBatteryStateChangedCb), this);
+ if (res != 0) {
+ LOG_RETURN(RES_FAIL, "vconf_notify_key_changed() failed");
+ }
+
+ res = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW,
+ CALLBACK_B(BatteryStateSource::onBatteryStateChangedCb), this);
+ if (res != 0) {
+ LOG_RETURN(RES_FAIL, "vconf_notify_key_changed() failed");
+ }
+
+ res = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY,
+ CALLBACK_B(BatteryStateSource::onBatteryStateChangedCb), this);
+ if (res != 0) {
+ LOG_RETURN(RES_FAIL, "vconf_notify_key_changed() failed");
+ }
+
+ return RES_OK;
+ }
+
+ void BatteryStateSource::delSysStateCallbacks()
+ {
+ vconf_ignore_key_changed(VCONFKEY_SYSMAN_CHARGER_STATUS,
+ CALLBACK_B(BatteryStateSource::onBatteryStateChangedCb));
+ vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW,
+ CALLBACK_B(BatteryStateSource::onBatteryStateChangedCb));
+ vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW,
+ CALLBACK_B(BatteryStateSource::onBatteryStateChangedCb));
+ vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY,
+ CALLBACK_B(BatteryStateSource::onBatteryStateChangedCb));
+ }
+
+ IndicatorState BatteryStateSource::getState() const
+ {
+ return {m_bits.value};
+ }
+
+ void BatteryStateSource::setStateChangeHandler(StateChangeHandler handler)
+ {
+ m_handler = handler;
+ }
+
+ int getBatteryLevel(IndicatorState state)
+ {
+ return static_cast<int>(
+ BatteryStateSource::Bits(state).chargeValue);
+ }
+
+ BatteryState getBatteryState(IndicatorState state)
+ {
+ return static_cast<BatteryState>(
+ BatteryStateSource::Bits(state).chargingState);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright 2017 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __CALLUI_MODEL_BATTERY_STATE_SOURCE_H__
+#define __CALLUI_MODEL_BATTERY_STATE_SOURCE_H__
+
+#include "IIndicatorStateSource.h"
+
+#include <vconf.h>
+
+#include "implTypes.h"
+
+namespace callui {
+
+ class BatteryStateSource final : public IIndicatorStateSource {
+ public:
+ static BatteryStateSourceSRef newInstance();
+ virtual ~BatteryStateSource();
+
+ // IIndicatorStateSource
+
+ virtual IndicatorState getState() const override final;
+ virtual void setStateChangeHandler(StateChangeHandler handler) override final;
+ private:
+ friend class ucl::RefCountObj<BatteryStateSource>;
+ BatteryStateSource();
+
+ ucl::Result prepare();
+
+ ucl::Result addSysStateCallbacks();
+ void delSysStateCallbacks();
+
+ void onBatteryStateChangedCb(keynode_t *node);
+
+ int getCurChargeLevel() const;
+ BatteryState getCurChargingState() const;
+
+ bool updateChargingStateBits(BatteryState state);
+ bool updateChargeLevelBits(int value);
+ bool updateBatteryState();
+
+ public:
+ union Bits {
+ struct {
+ uint8_t property : 4;
+ uint8_t chargeValue : 8;
+ uint8_t chargingState: 4;
+ };
+ uint64_t value;
+
+ Bits();
+ Bits(const IndicatorState &state);
+ };
+
+ private:
+ Bits m_bits;
+ StateChangeHandler m_handler;
+ };
+
+}
+
+#endif // __CALLUI_MODEL_BATTERY_STATE_SOURCE_H__
#include "IndicatorStateProvider.h"
#include "ConnectionStateSource.h"
#include "RssiStateSource.h"
+#include "BatteryStateSource.h"
#include "common.h"
IndicatorProperty::RSSI, rssiStateSource),
"setStateSource() failed!");
+ auto batteryStateSource = BatteryStateSource::newInstance();
+ if (!batteryStateSource) {
+ LOG_RETURN(RES_FAIL, "ConnectionStateSource::newInstance() failed!");
+ }
+ FAIL_RETURN(m_indicatorStateProvider->setStateSource(
+ IndicatorProperty::BATTERY, batteryStateSource),
+ "setStateSource() failed!");
+
return RES_OK;
}
using namespace ucl;
ConnectionStateSource::Bits::Bits():
- value(0)
+ property(convertEnumValueToInt(IndicatorProperty::NW_CONNECTION)),
+ connState(convertEnumValueToInt(ConnectionType::NONE)),
+ packetDirection(convertEnumValueToInt(PacketDirection::NONE))
{
- property = convertEnumValueToInt(IndicatorProperty::NW_CONNECTION);
}
ConnectionStateSource::Bits::Bits(const IndicatorState &state):
value(state.value)
{
+ if (property != convertEnumValueToInt(IndicatorProperty::NW_CONNECTION)) {
+ ELOG("State of incorrect property type [%d]", property);
+ *this = {};
+ }
}
ConnectionStateSource::ConnectionStateSource()
unsignSystStateCallbacks();
}
- IIndicatorStateSourceSRef ConnectionStateSource::newInstance()
+ ConnectionStateSourceSRef ConnectionStateSource::newInstance()
{
auto result = makeShared<ConnectionStateSource>();
FAIL_RETURN_VALUE(result->prepare(), {}, "result->prepare() failed!");
Result ConnectionStateSource::prepare()
{
- FAIL_RETURN(signSysStateCallbacks(), "signSysStateCallbacks() failed!");
+ FAIL_RETURN(addSysStateCallbacks(), "addSysStateCallbacks() failed!");
updateConnType();
updatePacketDir();
int wifiStrength = 0;
if (vconf_get_int(VCONFKEY_WIFI_STRENGTH, &wifiStrength) == 0) {
switch (wifiStrength) {
- case 1:
- return ConnectionType::WIFI_01;
- case 2:
- return ConnectionType::WIFI_02;
- case 3:
- return ConnectionType::WIFI_03;
- case 4:
- return ConnectionType::WIFI_04;
- default:
- return ConnectionType::WIFI_00;
+ case 1: return ConnectionType::WIFI_01;
+ case 2: return ConnectionType::WIFI_02;
+ case 3: return ConnectionType::WIFI_03;
+ case 4: return ConnectionType::WIFI_04;
+ default: return ConnectionType::WIFI_00;
}
- } else {
- ELOG("Get WiFi connection type failed!");
}
+ ELOG("Get WiFi connection type failed!");
return ConnectionType::NONE;
}
{
int type = 0;
if (vconf_get_int(VCONFKEY_TELEPHONY_PSTYPE, &type) == 0) {
- switch (type) {
- case VCONFKEY_TELEPHONY_PSTYPE_HSDPA:
- case VCONFKEY_TELEPHONY_PSTYPE_HSUPA:
+ switch(type) {
+ case VCONFKEY_TELEPHONY_PSTYPE_HSDPA :
+ case VCONFKEY_TELEPHONY_PSTYPE_HSUPA :
return ConnectionType::HSDPA_H;
- case VCONFKEY_TELEPHONY_PSTYPE_HSPA:
- case VCONFKEY_TELEPHONY_PSTYPE_HSPAP:
+ case VCONFKEY_TELEPHONY_PSTYPE_HSPA :
return ConnectionType::HSPA_H_PLUS;
- default:
- break;
+ default :
+ return ConnectionType::UMTS_3G;
}
- } else {
- ELOG("Get connection PS type failed!");
}
+ ELOG("Get connection PS type failed!");
return ConnectionType::NONE;
}
{
int svcType = 0;
if (vconf_get_int(VCONFKEY_TELEPHONY_SVCTYPE, &svcType) == 0) {
- switch (svcType) {
- case VCONFKEY_TELEPHONY_SVCTYPE_2G:
- return ConnectionType::SIMPLE_2G;
- case VCONFKEY_TELEPHONY_SVCTYPE_2_5G:
+ switch(svcType) {
+ case VCONFKEY_TELEPHONY_SVCTYPE_2G :
+ case VCONFKEY_TELEPHONY_SVCTYPE_2_5G :
return ConnectionType::GPRS_G;
- case VCONFKEY_TELEPHONY_SVCTYPE_3G:
- return ConnectionType::UMTS_3G;
- case VCONFKEY_TELEPHONY_SVCTYPE_2_5G_EDGE:
+ case VCONFKEY_TELEPHONY_SVCTYPE_3G :
+ return getConnTypeByTelephonyPsType();
+ case VCONFKEY_TELEPHONY_SVCTYPE_2_5G_EDGE :
return ConnectionType::EDGE_E;
- case VCONFKEY_TELEPHONY_SVCTYPE_LTE:
+ case VCONFKEY_TELEPHONY_SVCTYPE_LTE :
return ConnectionType::LTE_4G;
- default:
- break;
+ default :
+ return ConnectionType::NONE;
}
- } else {
- ELOG("Get connection SVC type failed!");
}
+ ELOG("Get connection SVC type failed!");
return ConnectionType::NONE;
}
return updateConnTypeBits(ConnectionType::NONE);
}
- ConnectionType connType = getConnTypeByTelephonyPsType();
- if (connType != ConnectionType::NONE) {
- return updateConnTypeBits(connType);
- }
-
- connType = getConnTypeByTelephonySvcType();
- if (connType != ConnectionType::NONE) {
- return updateConnTypeBits(connType);
- }
-
- return updateConnTypeBits(ConnectionType::NONE);
+ return updateConnTypeBits(getConnTypeByTelephonySvcType());
}
void ConnectionStateSource::onConnTypeChangedCb(keynode_t *node)
default:
return PacketDirection::NO_INPUT;
}
- } else {
- ELOG("Get WiFi transfer state failed");
}
+ ELOG("Get WiFi transfer state failed");
return PacketDirection::NONE;
}
int state = 0;
if (vconf_get_int(VCONFKEY_PACKET_STATE, &state) == 0) {
switch (state) {
- case VCONFKEY_PACKET_RX:
- return PacketDirection::IN;
- case VCONFKEY_PACKET_TX:
- return PacketDirection::OUT;
- case VCONFKEY_PACKET_RXTX:
- return PacketDirection::INOUT;
- default:
- return PacketDirection::NO_INPUT;
+ case VCONFKEY_PACKET_RX: return PacketDirection::IN;
+ case VCONFKEY_PACKET_TX: return PacketDirection::OUT;
+ case VCONFKEY_PACKET_RXTX: return PacketDirection::INOUT;
+ default: return PacketDirection::NO_INPUT;
}
- } else {
- ELOG("Get packet state failed");
}
+ ELOG("Get packet state failed");
return PacketDirection::NONE;
}
}
}
- Result ConnectionStateSource::signSysStateCallbacks()
+ Result ConnectionStateSource::addSysStateCallbacks()
{
// CONNECTION
int res = vconf_notify_key_changed(VCONFKEY_WIFI_STRENGTH,
m_handler = handler;
}
- ConnectionStateSource::Bits ConnectionStateSource::asBits(IndicatorState state)
- {
- Bits bits(state);
- if (static_cast<IndicatorProperty>(bits.property) != IndicatorProperty::NW_CONNECTION) {
- ELOG("State of incorrect property type [%d]", bits.property);
- return {};
- }
-
- return bits;
- }
-
ConnectionType getConnectionState(IndicatorState state)
{
return static_cast<ConnectionType>(
- ConnectionStateSource::asBits(state).connState);
+ ConnectionStateSource::Bits(state).connState);
}
PacketDirection getPacketDirection(IndicatorState state)
{
return static_cast<PacketDirection>(
- ConnectionStateSource::asBits(state).packetDirection);
+ ConnectionStateSource::Bits(state).packetDirection);
}
}
#include <vconf.h>
+#include "implTypes.h"
+
namespace callui {
class ConnectionStateSource final : public IIndicatorStateSource {
public:
- static IIndicatorStateSourceSRef newInstance();
+ static ConnectionStateSourceSRef newInstance();
virtual ~ConnectionStateSource();
// IIndicatorStateSource
ucl::Result prepare();
- ucl::Result signSysStateCallbacks();
+ ucl::Result addSysStateCallbacks();
void unsignSystStateCallbacks();
void onConnTypeChangedCb(keynode_t *node);
PacketDirection getPacketDirByPacketState() const;
bool updatePacketDir();
- private:
+ public:
union Bits {
struct {
uint8_t property : 4;
Bits();
Bits(const IndicatorState &state);
};
- public:
- static Bits asBits(IndicatorState state);
private:
Bits m_bits;
using namespace ucl;
RssiStateSource::Bits::Bits():
- value(0)
+ property(convertEnumValueToInt(IndicatorProperty::RSSI)),
+ rssiState(convertEnumValueToInt(RssiState::NONE)),
+ isRoamingEnable(0)
{
- property = convertEnumValueToInt(IndicatorProperty::RSSI);
}
RssiStateSource::Bits::Bits(const IndicatorState &state):
value(state.value)
{
+ if (property != convertEnumValueToInt(IndicatorProperty::RSSI)) {
+ ELOG("State of incorrect property type [%d]", property);
+ *this = {};
+ }
}
RssiStateSource::RssiStateSource()
RssiStateSource::~RssiStateSource()
{
- unsignSysStateCallbacks();
+ delSysStateCallbacks();
}
- IIndicatorStateSourceSRef RssiStateSource::newInstance()
+ RssiStateSourceSRef RssiStateSource::newInstance()
{
auto result = makeShared<RssiStateSource>();
FAIL_RETURN_VALUE(result->prepare(), {}, "result->prepare() failed!");
Result RssiStateSource::prepare()
{
- FAIL_RETURN(signSysStateCallbacks(), "signSysStateCallbacks() failed!");
+ FAIL_RETURN(addSysStateCallbacks(), "addSysStateCallbacks() failed!");
updateRssiState();
updateRoamingState();
}
}
- Result RssiStateSource::signSysStateCallbacks()
+ Result RssiStateSource::addSysStateCallbacks()
{
int res = vconf_notify_key_changed(VCONFKEY_TELEPHONY_SVC_ROAM,
CALLBACK_B(RssiStateSource::onRssiChangedCb), this);
return RES_OK;
}
- void RssiStateSource::unsignSysStateCallbacks()
+ void RssiStateSource::delSysStateCallbacks()
{
vconf_ignore_key_changed(VCONFKEY_TELEPHONY_SVC_ROAM,
CALLBACK_B(RssiStateSource::onRssiChangedCb));
m_handler = handler;
}
- RssiStateSource::Bits RssiStateSource::asBits(IndicatorState state)
- {
- Bits bits(state);
- if (static_cast<IndicatorProperty>(bits.property) != IndicatorProperty::RSSI) {
- ELOG("State of incorrect property type [%d]", bits.property);
- return {};
- }
-
- return bits;
- }
-
RssiState getRssiState(IndicatorState state)
{
return static_cast<RssiState>(
- RssiStateSource::asBits(state).rssiState);
+ RssiStateSource::Bits(state).rssiState);
}
bool getRoamingState(IndicatorState state)
{
- return RssiStateSource::asBits(state).isRoamingEnable;
+ return RssiStateSource::Bits(state).isRoamingEnable;
}
}
#include <vconf.h>
+#include "implTypes.h"
+
namespace callui {
class RssiStateSource final : public IIndicatorStateSource {
public:
- static IIndicatorStateSourceSRef newInstance();
+ static RssiStateSourceSRef newInstance();
virtual ~RssiStateSource();
// IIndicatorStateSource
RssiStateSource();
ucl::Result prepare();
- ucl::Result signSysStateCallbacks();
- void unsignSysStateCallbacks();
+ ucl::Result addSysStateCallbacks();
+ void delSysStateCallbacks();
bool isRoamingActive() const;
bool updateRssiStateBits(RssiState state);
void onRssiChangedCb(keynode_t *node);
- private:
+ public:
union Bits {
struct {
uint8_t property : 4;
uint8_t isRoamingEnable: 1;
};
uint64_t value;
+
Bits();
Bits(const IndicatorState &state);
};
- public:
- static Bits asBits(IndicatorState state);
-
private:
Bits m_bits;
StateChangeHandler m_handler;
UCL_DECLARE_REF_ALIASES(IndicatorStateProvider);
UCL_DECLARE_REF_ALIASES(IIndicatorStateSource);
+ UCL_DECLARE_REF_ALIASES(ConnectionStateSource);
+ UCL_DECLARE_REF_ALIASES(RssiStateSource);
+ UCL_DECLARE_REF_ALIASES(BatteryStateSource);
+
using AudioStateEvent = ucl::Event<AudioStateHandler>;
using MuteStateEvent = ucl::Event<MuteStateHandler>;
projects / profile / wearable / apps / native / call-ui.git / commitdiff