<tool id="org.tizen.nativecore.tool.sbi.gnu.archiver.mergelib.1347531198" name="Archive Generator" superClass="org.tizen.nativecore.tool.sbi.gnu.archiver.mergelib"/>
<tool id="org.tizen.nativecore.tool.sbi.po.compiler.1000732861" name="PO Resource Compiler" superClass="org.tizen.nativecore.tool.sbi.po.compiler"/>
<tool id="org.tizen.nativecore.tool.sbi.edc.compiler.692187818" name="EDC Resource Compiler" superClass="org.tizen.nativecore.tool.sbi.edc.compiler">
- <option id="sbi.gnu.edc.compiler.option.misc.id.434887912" superClass="sbi.gnu.edc.compiler.option.misc.id" valueType="stringList">
+ <option command="-id " id="sbi.gnu.edc.compiler.option.misc.id.434887912" name="Image Path (-id)" superClass="sbi.gnu.edc.compiler.option.misc.id" valueType="stringList">
<listOptionValue builtIn="false" value=""${workspace_loc:/${ProjName}}/edc/images""/>
</option>
</tool>
*/
color_classes {
+
+ // Incoming call circles
color_class { name: "AO0115";
color: 222 11 0 255;
}
color_class { name: "AO01132";
color: 97 237 50 77;
}
+
+ // Indicator Icons
+ color_class { name: "AO0111";
+ color: 255 255 255 255;
+ }
+
+ // Indicator battery
+ color_class { name: "AO0251";
+ color: 0 0 0 255;
+ }
+ color_class { name: "AO0254";
+ color: 255 0 0 255;
+ }
}
--- /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.
+ */
+
+#define CU_INDI_ICONS_DIR "/Indicator_icon"
+
+#define CU_CONN_IMAGE_DIR CU_INDI_ICONS_DIR"/Connection"
+#define CU_RSSI_IMAGE_DIR CU_INDI_ICONS_DIR"/4level"
+#define CU_BATT_IMAGE_DIR CU_INDI_ICONS_DIR"/Battery"
+
+// Connection
+
+#define CU_DESC_CONN_IMAGE(_value) \
+ desc { "state_"_value; \
+ inherit: "default"; \
+ visible: 1; \
+ image.normal: CU_CONN_IMAGE_DIR"/"_value".png"; \
+ } \
+
+#define CU_PROG_CONN_TYPE(_value) \
+ program { \
+ signal: "conn_"_value; \
+ source: "*"; \
+ action: STATE_SET "state_"_value; \
+ target: "img.connection_type"; \
+ } \
+
+#define CU_PROG_PACKET_DIRECTION(_value) \
+ program { \
+ signal: "packet_"_value; \
+ source: "*"; \
+ action: STATE_SET "state_"_value; \
+ target: "img.connection_packet"; \
+ } \
+
+group { "elm/layout/callui/connection";
+ images {
+ image: CU_CONN_IMAGE_DIR"/edge_connected.png" COMP;
+ image: CU_CONN_IMAGE_DIR"/gprs_connected.png" COMP;
+ image: CU_CONN_IMAGE_DIR"/hsdpa_connected.png" COMP;
+ image: CU_CONN_IMAGE_DIR"/hspa_connected.png" COMP;
+ image: CU_CONN_IMAGE_DIR"/lte_connected.png" COMP;
+ image: CU_CONN_IMAGE_DIR"/umts_connected.png" COMP;
+ image: CU_CONN_IMAGE_DIR"/wifi_connected_00.png" COMP;
+ image: CU_CONN_IMAGE_DIR"/wifi_connected_01.png" COMP;
+ image: CU_CONN_IMAGE_DIR"/wifi_connected_02.png" COMP;
+ image: CU_CONN_IMAGE_DIR"/wifi_connected_03.png" COMP;
+ image: CU_CONN_IMAGE_DIR"/wifi_connected_04.png" COMP;
+
+ image: CU_CONN_IMAGE_DIR"/no_inout_connected.png" COMP;
+ image: CU_CONN_IMAGE_DIR"/in_connected.png" COMP;
+ image: CU_CONN_IMAGE_DIR"/out_connected.png" COMP;
+ image: CU_CONN_IMAGE_DIR"/inout_connected.png" COMP;
+ }
+ parts {
+ image { "img.connection_type";
+ scale;
+ desc { "default";
+ min: CU_INDI_ICON_W CU_INDI_ICON_H;
+ max: CU_INDI_ICON_W CU_INDI_ICON_H;
+ fixed: 1 1;
+ image.normal: CU_CONN_IMAGE_DIR"/edge_connected.png";
+ color_class: "AO0111";
+ visible: 0;
+ }
+ CU_DESC_CONN_IMAGE("edge_connected");
+ CU_DESC_CONN_IMAGE("gprs_connected");
+ CU_DESC_CONN_IMAGE("hsdpa_connected");
+ CU_DESC_CONN_IMAGE("hspa_connected");
+ CU_DESC_CONN_IMAGE("lte_connected");
+ CU_DESC_CONN_IMAGE("umts_connected");
+ CU_DESC_CONN_IMAGE("wifi_connected_00");
+ CU_DESC_CONN_IMAGE("wifi_connected_01");
+ CU_DESC_CONN_IMAGE("wifi_connected_02");
+ CU_DESC_CONN_IMAGE("wifi_connected_03");
+ CU_DESC_CONN_IMAGE("wifi_connected_04");
+ }
+ image { "img.connection_packet";
+ scale;
+ desc { "default";
+ fixed: 1 1;
+ min: CU_INDI_ICON_W CU_INDI_ICON_H;
+ max: CU_INDI_ICON_W CU_INDI_ICON_H;
+ image.normal: CU_CONN_IMAGE_DIR"/no_inout_connected.png";
+ color_class: "AO0111";
+ visible: 0;
+ }
+ CU_DESC_CONN_IMAGE("no_inout_connected");
+ CU_DESC_CONN_IMAGE("in_connected");
+ CU_DESC_CONN_IMAGE("out_connected");
+ CU_DESC_CONN_IMAGE("inout_connected");
+ }
+ }
+
+ programs {
+ CU_PROG_CONN_TYPE("edge_connected");
+ CU_PROG_CONN_TYPE("gprs_connected");
+ CU_PROG_CONN_TYPE("hsdpa_connected");
+ CU_PROG_CONN_TYPE("hspa_connected");
+ CU_PROG_CONN_TYPE("lte_connected");
+ CU_PROG_CONN_TYPE("umts_connected");
+ CU_PROG_CONN_TYPE("3g_plus_connected");
+ CU_PROG_CONN_TYPE("wifi_connected_00");
+ CU_PROG_CONN_TYPE("wifi_connected_01");
+ CU_PROG_CONN_TYPE("wifi_connected_02");
+ CU_PROG_CONN_TYPE("wifi_connected_03");
+ CU_PROG_CONN_TYPE("wifi_connected_04");
+ program {
+ signal: "connection_none";
+ source: "*";
+ action: STATE_SET "default";
+ target: "img.connection_type";
+ target: "img.connection_packet";
+ }
+ CU_PROG_PACKET_DIRECTION("no_inout_connected");
+ CU_PROG_PACKET_DIRECTION("in_connected");
+ CU_PROG_PACKET_DIRECTION("out_connected");
+ CU_PROG_PACKET_DIRECTION("inout_connected");
+ program {
+ signal: "packet_none";
+ source: "*";
+ action: STATE_SET "default";
+ target: "img.connection_packet";
+ }
+ }
+}
+
+// RSSI
+
+#define CU_DESC_RSSI_IMAGE(_num) \
+ description { \
+ state: _num; \
+ inherit: "default"; \
+ image.normal: CU_RSSI_IMAGE_DIR"/signal_strength_"_num".png"; \
+ } \
+
+#define CU_DESC_RSSI_ROAMING_IMAGE(_num) \
+ description { \
+ state: "roaming_"_num; \
+ inherit: "default"; \
+ image.normal: CU_RSSI_IMAGE_DIR"/roaming_strength_"_num".png"; \
+ } \
+
+#define CU_PROG_RSSI(_num) \
+ program { \
+ signal: "rssi_"_num; \
+ source: "*"; \
+ action: STATE_SET _num 0.0; \
+ target: "img.rssi"; \
+ } \
+
+#define CU_PROG_RSSI_ROAMING(_num) \
+ program { \
+ signal: "rssi_roaming_"_num; \
+ source: "*"; \
+ action: STATE_SET "roaming_"_num 0.0; \
+ target: "img.rssi"; \
+ } \
+
+group { "elm/layout/callui/rssi";
+ images {
+ image: CU_RSSI_IMAGE_DIR"/signal_strength_00.png" COMP;
+ image: CU_RSSI_IMAGE_DIR"/signal_strength_01.png" COMP;
+ image: CU_RSSI_IMAGE_DIR"/signal_strength_02.png" COMP;
+ image: CU_RSSI_IMAGE_DIR"/signal_strength_03.png" COMP;
+ image: CU_RSSI_IMAGE_DIR"/signal_strength_04.png" COMP;
+ image: CU_RSSI_IMAGE_DIR"/roaming_strength_00.png" COMP;
+ image: CU_RSSI_IMAGE_DIR"/roaming_strength_01.png" COMP;
+ image: CU_RSSI_IMAGE_DIR"/roaming_strength_02.png" COMP;
+ image: CU_RSSI_IMAGE_DIR"/roaming_strength_03.png" COMP;
+ image: CU_RSSI_IMAGE_DIR"/roaming_strength_04.png" COMP;
+ image: CU_INDI_ICONS_DIR"/b_ic_flight.png" COMP;
+ image: CU_INDI_ICONS_DIR"/b_ic_indicator_02.png" COMP;
+ }
+ parts {
+ image { "img.rssi";
+ scale;
+ desc { "default";
+ fixed: 1 1;
+ min: CU_INDI_ICON_W CU_INDI_ICON_H;
+ max: CU_INDI_ICON_W CU_INDI_ICON_H;
+ image.normal: CU_INDI_ICONS_DIR"/b_ic_indicator_02.png";
+ color_class: "AO0111";
+ }
+ CU_DESC_RSSI_IMAGE(00);
+ CU_DESC_RSSI_IMAGE(01);
+ CU_DESC_RSSI_IMAGE(02);
+ CU_DESC_RSSI_IMAGE(03);
+ CU_DESC_RSSI_IMAGE(04);
+ CU_DESC_RSSI_ROAMING_IMAGE(00);
+ CU_DESC_RSSI_ROAMING_IMAGE(01);
+ CU_DESC_RSSI_ROAMING_IMAGE(02);
+ CU_DESC_RSSI_ROAMING_IMAGE(03);
+ CU_DESC_RSSI_ROAMING_IMAGE(04);
+ desc { "no_signal";
+ inherit: "default";
+ }
+ desc { "flight_mode";
+ inherit: "default";
+ image.normal: CU_INDI_ICONS_DIR"/b_ic_flight.png";
+ }
+ desc { "none";
+ inherit: "default";
+ visible: 0;
+ }
+ }
+ }
+ programs {
+ CU_PROG_RSSI(00);
+ CU_PROG_RSSI(01);
+ CU_PROG_RSSI(02);
+ CU_PROG_RSSI(03);
+ CU_PROG_RSSI(04);
+ CU_PROG_RSSI_ROAMING(00);
+ CU_PROG_RSSI_ROAMING(01);
+ CU_PROG_RSSI_ROAMING(02);
+ CU_PROG_RSSI_ROAMING(03);
+ CU_PROG_RSSI_ROAMING(04);
+ program {
+ signal: "rssi_no_signal";
+ source: "*";
+ action: STATE_SET "no_signal" 0.0;
+ target: "img.rssi";
+ }
+ program {
+ signal: "rssi_flight_mode";
+ source: "*";
+ action: STATE_SET "flight_mode" 0.0;
+ target: "img.rssi";
+ }
+ program {
+ signal: "rssi_none";
+ source: "*";
+ action: STATE_SET "none" 0.0;
+ target: "img.rssi";
+ }
+ }
+}
+
+// BATTERY
+
+#define DESCRIPTION_BATTERY(_value) \
+ desc { "batt_lvl_"_value; \
+ inherit: "default"; \
+ image.normal: CU_BATT_IMAGE_DIR"/battery_"_value".png"; \
+ } \
+
+#define PROGRAM_BATTERY(_value) \
+ program { \
+ signal: "batt_lvl_"_value; \
+ source: "*"; \
+ action: STATE_SET "batt_lvl_"_value; \
+ target: "img.battery_level"; \
+ } \
+
+group { "elm/layout/callui/battery";
+ images {
+ image: CU_BATT_IMAGE_DIR"/battery_00.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_05.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_10.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_15.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_20.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_25.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_30.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_35.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_40.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_45.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_50.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_55.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_60.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_65.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_70.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_75.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_80.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_85.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_90.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_95.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_100.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_bg.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_charging.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_not_charging.png" COMP;
+ image: CU_BATT_IMAGE_DIR"/battery_unknown.png" COMP;
+ }
+ parts {
+ image { "img.battery.bg";
+ scale;
+ desc { "default";
+ fixed: 1 1;
+ min: CU_BATT_ICON_W CU_BATT_ICON_H;
+ max: CU_BATT_ICON_W CU_BATT_ICON_H;
+ image.normal: CU_BATT_IMAGE_DIR"/battery_bg.png";
+ color_class: "AO0111";
+ }
+ }
+ image { "img.battery_level";
+ scale;
+ desc { "default";
+ fixed: 1 1;
+ min: CU_BATT_ICON_W CU_BATT_ICON_H;
+ max: CU_BATT_ICON_W CU_BATT_ICON_H;
+ image.normal: CU_BATT_IMAGE_DIR"/battery_50.png";
+ color_class: "AO0111";
+ }
+ desc { "batt_lvl_hide";
+ inherit: "default";
+ visible: 0;
+ }
+ DESCRIPTION_BATTERY(05);
+ DESCRIPTION_BATTERY(10);
+ DESCRIPTION_BATTERY(15);
+ DESCRIPTION_BATTERY(20);
+ DESCRIPTION_BATTERY(25);
+ DESCRIPTION_BATTERY(30);
+ DESCRIPTION_BATTERY(35);
+ DESCRIPTION_BATTERY(40);
+ DESCRIPTION_BATTERY(45);
+ DESCRIPTION_BATTERY(50);
+ DESCRIPTION_BATTERY(55);
+ DESCRIPTION_BATTERY(60);
+ DESCRIPTION_BATTERY(65);
+ DESCRIPTION_BATTERY(70);
+ DESCRIPTION_BATTERY(75);
+ DESCRIPTION_BATTERY(80);
+ DESCRIPTION_BATTERY(85);
+ DESCRIPTION_BATTERY(90);
+ DESCRIPTION_BATTERY(95);
+ DESCRIPTION_BATTERY(100);
+ }
+ image { "img.charge";
+ scale;
+ desc { "default";
+ fixed: 1 1;
+ min: CU_BATT_ICON_W CU_BATT_ICON_H;
+ max: CU_BATT_ICON_W CU_BATT_ICON_H;
+ image.normal: CU_BATT_IMAGE_DIR"/battery_00.png";
+ color_class: "AO0111";
+ visible: 0;
+ }
+ desc { "low_battery";
+ inherit: "default";
+ visible: 1;
+ }
+ desc { "charging";
+ inherit: "default";
+ image.normal: CU_BATT_IMAGE_DIR"/battery_charging.png";
+ color_class: "AO0251";
+ visible: 1;
+ }
+ desc { "charging_problem";
+ inherit: "default";
+ image.normal: CU_BATT_IMAGE_DIR"/battery_not_charging.png";
+ color_class: "AO0254";
+ visible: 1;
+ }
+ desc { "unknown";
+ inherit: "default";
+ image.normal: CU_BATT_IMAGE_DIR"/battery_unknown.png";
+ color_class: "AO0251";
+ visible: 1;
+ }
+ }
+ }
+
+ programs {
+ PROGRAM_BATTERY(hide);
+ PROGRAM_BATTERY(05);
+ PROGRAM_BATTERY(10);
+ PROGRAM_BATTERY(15);
+ PROGRAM_BATTERY(20);
+ PROGRAM_BATTERY(25);
+ PROGRAM_BATTERY(30);
+ PROGRAM_BATTERY(35);
+ PROGRAM_BATTERY(40);
+ PROGRAM_BATTERY(45);
+ PROGRAM_BATTERY(50);
+ PROGRAM_BATTERY(55);
+ PROGRAM_BATTERY(60);
+ PROGRAM_BATTERY(65);
+ PROGRAM_BATTERY(70);
+ PROGRAM_BATTERY(75);
+ PROGRAM_BATTERY(80);
+ PROGRAM_BATTERY(85);
+ PROGRAM_BATTERY(90);
+ PROGRAM_BATTERY(95);
+ PROGRAM_BATTERY(100);
+ program {
+ signal: "batt_state_normal";
+ source: "*";
+ action: STATE_SET "default";
+ target: "img.charge";
+ }
+ program {
+ signal: "batt_state_low_battery";
+ source: "*";
+ action: STATE_SET "low_battery";
+ target: "img.charge";
+ }
+ program {
+ signal: "batt_state_charging";
+ source: "*";
+ action: STATE_SET "charging" ;
+ target: "img.charge";
+ }
+ program {
+ signal: "batt_state_charging_problem";
+ source: "*";
+ action: STATE_SET "charging_problem" ;
+ target: "img.charge";
+ }
+ program {
+ signal: "batt_state_unknown";
+ source: "*";
+ action: STATE_SET "unknown";
+ target: "img.charge";
+ }
+ }
+}
+
+// SIM
+
+group { "elm/layout/callui/sim";
+ images {
+ image: CU_INDI_ICONS_DIR"/indi_forwarded_call.png" COMP;
+ image: CU_INDI_ICONS_DIR"/indi_gear_sim_call.png" COMP;
+ image: CU_INDI_ICONS_DIR"/indi_mobile_sim_01.png" COMP;
+ image: CU_INDI_ICONS_DIR"/indi_mobile_sim_02.png" COMP;
+ image: CU_INDI_ICONS_DIR"/indi_mobile_sim_call.png" COMP;
+ }
+ parts {
+ image { "img.sim";
+ scale;
+ desc { "default";
+ fixed: 1 1;
+ min: CU_INDI_ICON_W CU_INDI_ICON_H;
+ max: CU_INDI_ICON_W CU_INDI_ICON_H;
+ image.normal: CU_INDI_ICONS_DIR"/indi_gear_sim_call.png";
+ color_class: "AO0111";
+ visible: 0;
+ }
+ desc { "unknown";
+ inherit: "default";
+ }
+ desc { "gear_sim_call";
+ inherit: "default";
+ visible: 1;
+ }
+ desc { "forwarded_call";
+ inherit: "default";
+ image.normal: CU_INDI_ICONS_DIR"/indi_forwarded_call.png";
+ visible: 1;
+ }
+ desc { "mobile_sim_call";
+ inherit: "default";
+ image.normal: CU_INDI_ICONS_DIR"/indi_mobile_sim_call.png";
+ visible: 1;
+ }
+ desc { "mobile_sim_01";
+ inherit: "default";
+ image.normal: CU_INDI_ICONS_DIR"/indi_mobile_sim_01.png";
+ visible: 1;
+ }
+ desc { "mobile_sim_02";
+ inherit: "default";
+ image.normal: CU_INDI_ICONS_DIR"/indi_mobile_sim_02.png";
+ visible: 1;
+ }
+ }
+ }
+ programs {
+ program {
+ signal: "sim_unknown";
+ source: "*";
+ action: STATE_SET "unknown" 0.0;
+ target: "img.sim";
+ }
+ program {
+ signal: "sim_gear";
+ source: "*";
+ action: STATE_SET "gear_sim_call" 0.0;
+ target: "img.sim";
+ }
+ program {
+ signal: "sim_gear_forwarded";
+ source: "*";
+ action: STATE_SET "forwarded_call" 0.0;
+ target: "img.sim";
+ }
+ program {
+ signal: "sim_mobile";
+ source: "*";
+ action: STATE_SET "mobile_sim_call" 0.0;
+ target: "img.sim";
+ }
+ program {
+ signal: "sim_mobile_01";
+ source: "*";
+ action: STATE_SET "mobile_sim_01" 0.0;
+ target: "img.sim";
+ }
+ program {
+ signal: "sim_mobile_02";
+ source: "*";
+ action: STATE_SET "mobile_sim_02" 0.0;
+ target: "img.sim";
+ }
+ }
+}
+
+// HD Voice
+
+group { "elm/layout/callui/hd_voice";
+ images {
+ image: CU_INDI_ICONS_DIR"/indi_hd_voice_call.png" COMP;
+ }
+ parts {
+ image { "img.hd_voice";
+ scale;
+ desc { "default";
+ fixed: 1 1;
+ min: CU_INDI_ICON_W CU_INDI_ICON_H;
+ max: CU_INDI_ICON_W CU_INDI_ICON_H;
+ image.normal: CU_INDI_ICONS_DIR"/indi_hd_voice_call.png";
+ color_class: "AO0111";
+ visible: 0;
+ }
+ desc { "disabled";
+ inherit: "default";
+ }
+ desc { "enabled";
+ inherit: "default";
+ visible: 1;
+ }
+ }
+ }
+ programs {
+ program {
+ signal: "hd_voice_show";
+ source: "*";
+ action: STATE_SET "enabled" 0.0;
+ target: "img.hd_voice";
+ }
+ program {
+ signal: "hd_voice_hide";
+ source: "*";
+ action: STATE_SET "disabled" 0.0;
+ target: "img.hd_voice";
+ }
+ }
+}
\ No newline at end of file
#define CU_BTN_HIDE_ANIM_TIME 0.2
+#define CU_SWL_CONN_COORD_X 104
+#define CU_SWL_CONN_COORD_Y 31
+
+#define CU_SWL_RSSI_COORD_X 135
+#define CU_SWL_RSSI_COORD_Y 20
+
+#define CU_SWL_BATT_COORD_X 169
+#define CU_SWL_BATT_COORD_Y 14
+
+#define CU_SWL_SIM_COORD_X 201
+#define CU_SWL_SIM_COORD_Y 20
+
+#define CU_SWL_HD_CALL_COORD_X 232
+#define CU_SWL_HD_CALL_COORD_Y 31
+
+#define CU_SWL_CONN_REL1 CU_REL_W(CU_SWL_CONN_COORD_X) CU_REL_H(CU_SWL_CONN_COORD_Y)
+#define CU_SWL_CONN_REL2 CU_REL_W((CU_SWL_CONN_COORD_X+CU_INDI_ICON_W)) CU_REL_H((CU_SWL_CONN_COORD_Y+CU_INDI_ICON_H))
+
+#define CU_SWL_RSSI_REL1 CU_REL_W(CU_SWL_RSSI_COORD_X) CU_REL_H(CU_SWL_RSSI_COORD_Y)
+#define CU_SWL_RSSI_REL2 CU_REL_W((CU_SWL_RSSI_COORD_X+CU_INDI_ICON_W)) CU_REL_H((CU_SWL_RSSI_COORD_Y+CU_INDI_ICON_H))
+
+#define CU_SWL_BATTERY_REL1 CU_REL_W(CU_SWL_BATT_COORD_X) CU_REL_H(CU_SWL_BATT_COORD_Y)
+#define CU_SWL_BATTERY_REL2 CU_REL_W((CU_SWL_BATT_COORD_X+CU_BATT_ICON_W)) CU_REL_H((CU_SWL_BATT_COORD_Y+CU_BATT_ICON_H))
+
+#define CU_SWL_SIM_REL1 CU_REL_W(CU_SWL_SIM_COORD_X) CU_REL_H(CU_SWL_SIM_COORD_Y)
+#define CU_SWL_SIM_REL2 CU_REL_W((CU_SWL_SIM_COORD_X+CU_INDI_ICON_W)) CU_REL_H((CU_SWL_SIM_COORD_Y+CU_INDI_ICON_H))
+
+#define CU_SWL_HD_CALL_REL1 CU_REL_W(CU_SWL_HD_CALL_COORD_X) CU_REL_H(CU_SWL_HD_CALL_COORD_Y)
+#define CU_SWL_HD_CALL_REL2 CU_REL_W((CU_SWL_HD_CALL_COORD_X+CU_INDI_ICON_W)) CU_REL_H((CU_SWL_HD_CALL_COORD_Y+CU_INDI_ICON_H))
+
+
group { "elm/layout/callui/main";
parts {
+ swallow { "swl.indicator";
+ scale;
+ desc { "default";
+ }
+ }
swallow { "swl.accept_reject";
scale;
desc { "default";
}
}
-group { "elm/layout/callui/incoming_call";
+group { "elm/layout/callui/accept_reject";
parts {
spacer { "spacer.left";
scale;
targets: "spacer.right" "spacer.left";
}
}
+}
+group { "elm/layout/callui/indicator";
+ parts {
+ spacer { "bg";
+ scale;
+ desc { "default";
+ }
+ }
+ swallow { "swl.connection";
+ scale;
+ desc { "default";
+ rel1 { relative: CU_SWL_CONN_REL1; to: "bg"; }
+ rel2 { relative: CU_SWL_CONN_REL2; to: "bg"; }
+ }
+ }
+ swallow { "swl.rssi";
+ scale;
+ desc { "default";
+ rel1 { relative: CU_SWL_RSSI_REL1; to: "bg"; }
+ rel2 { relative: CU_SWL_RSSI_REL2; to: "bg"; }
+ }
+ }
+ swallow { "swl.battery";
+ scale;
+ desc { "default";
+ rel1 { relative: CU_SWL_BATTERY_REL1; to: "bg"; }
+ rel2 { relative: CU_SWL_BATTERY_REL2; to: "bg"; }
+ }
+ }
+ swallow { "swl.sim";
+ scale;
+ desc { "default";
+ rel1 { relative: CU_SWL_SIM_REL1; to: "bg"; }
+ rel2 { relative: CU_SWL_SIM_REL2; to: "bg"; }
+ }
+ }
+ swallow { "swl.hd_voice";
+ scale;
+ desc { "default";
+ rel1 { relative: CU_SWL_HD_CALL_REL1; to: "bg"; }
+ rel2 { relative: CU_SWL_HD_CALL_REL2; to: "bg"; }
+ }
+ }
+ }
}
\ No newline at end of file
virtual long getStartTime() const = 0;
virtual bool isEmergency() const = 0;
virtual bool isHDVoice() const = 0;
+ virtual bool isForwarded() const = 0;
virtual int getConferenceMemberCount() const = 0;
virtual const ConfMemberList &getConferenceMemberList() const = 0;
};
class IIndicatorStateListener: public ucl::Polymorphic {
public:
- virtual void onStateChanged(IndicatorProperty property) const = 0;
+ virtual void onStateChanged(IndicatorProperty property) = 0;
};
}
int getBatteryLevel(IndicatorState state);
BatteryState getBatteryState(IndicatorState state);
SimSlot getSimSlotType(IndicatorState state);
+ bool getSimForwardState(IndicatorState state);
bool getHDVoiceState(IndicatorState state);
}
--- /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_PRESENTERS_INDICATOR_H__
+#define __CALLUI_PRESENTERS_INDICATOR_H__
+
+#include "model/IIndicatorStateListener.h"
+
+#include "ucl/gui/Layout.h"
+#include "ucl/gui/StyledWidget.h"
+
+#include "types.h"
+
+namespace callui {
+
+ class Indicator final :
+ public IIndicatorStateListener,
+ public ucl::RefCountAware {
+ public:
+ class Builder {
+ public:
+ Builder();
+ ~Builder();
+ Builder &setIndicatorStateProvider(const IIndicatorStateProviderSRef &provider);
+ IndicatorSRef build(ucl::ElmWidget &parent) const;
+ private:
+ IIndicatorStateProviderSRef m_provider;
+ };
+
+ public:
+ virtual ~Indicator();
+
+ ucl::Widget &getWidget();
+
+ private:
+ friend class ucl::RefCountObj<Indicator>;
+ Indicator(ucl::RefCountObjBase &rc,
+ const IIndicatorStateProviderSRef &provider);
+
+ ucl::Result prepare(ucl::Widget &parent);
+
+ ucl::Result createWidget(ucl::Widget &parent);
+ ucl::Result createConnectionLayout();
+ ucl::Result createRssiLayout();
+ ucl::Result createBatteryLayout();
+ ucl::Result createSimLayout();
+ ucl::Result createHdVoiceLayout();
+
+ void updateConnectionState();
+ void updateRssiState();
+ void updateBatteryState();
+ void updateSimState();
+ void updateHdVoiceState();
+
+ // IIndicatorStateListener
+
+ virtual void onStateChanged(IndicatorProperty property) override final;
+
+ private:
+ ucl::LayoutSRef m_widget;
+ ucl::LayoutSRef m_connLayout;
+ ucl::LayoutSRef m_rssiLayout;
+ ucl::LayoutSRef m_batteryLayout;
+ ucl::LayoutSRef m_simLayout;
+ ucl::LayoutSRef m_hdCallLayout;
+ IIndicatorStateProviderSRef m_provider;
+ };
+
+ ucl::EdjeSignal getConnectionSignal(ConnectionType type);
+}
+
+#endif // __CALLUI_PRESENTERS_INDICATOR_H__
private:
ucl::LayoutSRef m_widget;
ICallSRef m_call;
+ IndicatorSRef m_indicator;
AcceptRejectPresenterSRef m_acceptReject;
};
}
UCL_DECLARE_REF_ALIASES(AcceptRejectPresenter);
UCL_DECLARE_REF_ALIASES(AcceptDialog);
+ UCL_DECLARE_REF_ALIASES(Indicator);
+
using AcceptDialogHandler = ucl::WeakDelegate<bool(AcceptDialog &, AcceptDialogEvent)>;
}
#define TRANSITION_GLIDE(duration) CUBIC_BEZIER (duration) 0.25 0.46 0.45 1.0
+#define CU_WIN_W 360
+#define CU_WIN_H 360
+
+#define CU_REL_W(val) (val/CU_WIN_W)
+#define CU_REL_H(val) (val/CU_WIN_H)
+
+#define CU_BATT_ICON_H 32
+#define CU_BATT_ICON_W 22
+
+#define CU_INDI_ICON_H 26
+#define CU_INDI_ICON_W 24
+
collections {
base_scale: 1.3;
#include "../../edc/color_classes.edc"
#include "../../edc/layouts.edc"
#include "../../edc/buttons.edc"
+
+ #include "../../edc/indicator.edc"
}
virtual IndicatorState getState() const override final;
virtual void setStateChangeHandler(StateChangeHandler handler) override final;
+
private:
friend class ucl::RefCountObj<BatteryStateSource>;
BatteryStateSource();
"setStateSource() failed!");
m_simSlotStSrc = makeShared<SimSlotStateSource>(
- m_callManager->getSimSlot());
+ m_callManager->getSimSlot(), getForwardedCallStatus());
FAIL_RETURN(m_indicatorStPrv->setStateSource(
IndicatorProperty::SIM_SLOT, m_simSlotStSrc),
"setStateSource() failed!");
return m_indicatorStPrv;
}
- bool Call::getHDVoiceStatus() const
+ ICallInfoSCRef Call::getCurrentCallInfo() const
{
- ICallInfoSCRef info;
CallMask calls = m_callManager->getAvailableCalls();
if (!calls) {
DLOG("No available calls");
- return false;
+ return {};
} else if (calls & CALL_FLAG_INCOMING) {
- info = m_callManager->getIncomingCall()->getInfo();
+ return m_callManager->getIncomingCall()->getInfo();
} else if (calls & CALL_FLAG_ACTIVE) {
- info = m_callManager->getActiveCall()->getInfo();
+ return m_callManager->getActiveCall()->getInfo();
} else if (calls & CALL_FLAG_HELD) {
- info = m_callManager->getHeldCall()->getInfo();
+ return m_callManager->getHeldCall()->getInfo();
} else if (calls & CALL_FLAG_END) {
- info = m_callManager->getEndCall()->getInfo();
+ return m_callManager->getEndCall()->getInfo();
+ }
+ return {};
+ }
+
+ bool Call::getHDVoiceStatus() const
+ {
+ ICallInfoSCRef info = getCurrentCallInfo();
+ if (info) {
+ return info->isHDVoice();
+ }
+ return false;
+ }
+
+ bool Call::getForwardedCallStatus() const
+ {
+ ICallInfoSCRef info = getCurrentCallInfo();
+ if (info) {
+ return info->isForwarded();
}
- return info->isHDVoice();
+ return false;
}
void Call::updateHdVoiceStateSource()
void Call::updateSimSlotStateSource()
{
- m_simSlotStSrc->updateSimSlot(m_callManager->getSimSlot());
+ m_simSlotStSrc->updateSimSlot(m_callManager->getSimSlot(),
+ getForwardedCallStatus());
}
void Call::onCallEvent(CallEventType type)
ucl::Result prepare();
ucl::Result initInidcatorStateProvider();
- bool getHDVoiceStatus() const;
+
void updateHdVoiceStateSource();
void updateSimSlotStateSource();
+ ICallInfoSCRef getCurrentCallInfo() const;
+ bool getHDVoiceStatus() const;
+ bool getForwardedCallStatus() const;
private:
CallManagerSRef m_callManager;
m_startTime(0),
m_isEmergency(false),
m_isHDVoice(false),
+ m_isForwarded(false),
m_confMemberCount(0)
{
}
return m_isHDVoice;
}
+ bool CallInfo::isForwarded() const
+ {
+ return m_isForwarded;
+ }
+
int CallInfo::getConferenceMemberCount() const
{
return m_confMemberCount;
virtual long getStartTime() const override final;
virtual bool isEmergency() const override final;
virtual bool isHDVoice() const override final;
+ virtual bool isForwarded() const override final;
virtual int getConferenceMemberCount() const override final;
virtual const ConfMemberList &getConferenceMemberList() const override final;
long m_startTime;
bool m_isEmergency;
bool m_isHDVoice;
+ bool m_isForwarded;
int m_confMemberCount;
ConfMemberList m_confMemberList;
};
}
}
- SimSlotStateSource::SimSlotStateSource(SimSlot slot)
+ SimSlotStateSource::SimSlotStateSource(SimSlot slot, bool isForwarded)
{
m_bits.simSlot = convertEnumValueToInt(slot);
+ m_bits.isForwarded = isForwarded;
}
SimSlotStateSource::~SimSlotStateSource()
{
}
- void SimSlotStateSource::updateSimSlot(SimSlot slot)
+ void SimSlotStateSource::updateSimSlot(SimSlot slot, bool isForwarded)
{
int simSlotInt = convertEnumValueToInt(slot);
+ bool needUpdate = false;
+
if (simSlotInt != m_bits.simSlot) {
m_bits.simSlot = simSlotInt;
- if (m_handler) {
- m_handler();
- }
+ needUpdate = true;
+ }
+
+ if (isForwarded != m_bits.isForwarded) {
+ m_bits.isForwarded = isForwarded;
+ needUpdate = true;
+ }
+
+ if (needUpdate && m_handler) {
+ m_handler();
}
}
SimSlotStateSource::Bits(state).simSlot);
}
+ bool getSimForwardState(IndicatorState state)
+ {
+ return SimSlotStateSource::Bits(state).isForwarded;
+ }
+
}
class SimSlotStateSource final : public IIndicatorStateSource {
public:
- SimSlotStateSource(SimSlot slot);
+ SimSlotStateSource(SimSlot slot, bool isForwarded);
virtual ~SimSlotStateSource();
- void updateSimSlot(SimSlot slot);
+ void updateSimSlot(SimSlot slot, bool isForwarded);
// IIndicatorStateSource
struct {
uint8_t property : 4;
uint8_t simSlot : 4;
+ bool isForwarded: 1;
};
uint64_t value;
using namespace ucl;
- constexpr LayoutTheme LAYOUT_INCOMING_CALL_WIDGET
- {"layout", "callui", "incoming_call"};
+ constexpr LayoutTheme LAYOUT_ACCEPT_REJECT_WIDGET
+ {"layout", "callui", "accept_reject"};
constexpr EdjeSignal SIGNAL_ACCEEPT_SHOW {"accept,show"};
constexpr EdjeSignal SIGNAL_ACCEEPT_HIDE {"accept,hide"};
Result AcceptRejectPresenter::createWidget(Widget &parent)
{
m_widget = Layout::Builder().
- setTheme(impl::LAYOUT_INCOMING_CALL_WIDGET).
+ setTheme(impl::LAYOUT_ACCEPT_REJECT_WIDGET).
setIsOwner(true).
build(parent);
if (!m_widget) {
--- /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 "presenters/Indicator.h"
+
+#include <string>
+
+#include "model/IIndicatorStateProvider.h"
+
+#include "common.h"
+
+namespace callui { namespace { namespace impl {
+ using namespace ucl;
+
+ constexpr int BATTERY_LOW_LIMIT = 5;
+
+ constexpr LayoutTheme LAYOUT_INDICATOR_WIDGET
+ {"layout", "callui", "indicator"};
+
+ constexpr LayoutTheme LAYOUT_CONNECTION
+ {"layout", "callui", "connection"};
+
+ constexpr LayoutTheme LAYOUT_RSSI
+ {"layout", "callui", "rssi"};
+
+ constexpr LayoutTheme LAYOUT_BATTERY
+ {"layout", "callui", "battery"};
+
+ constexpr LayoutTheme LAYOUT_SIM
+ {"layout", "callui", "sim"};
+
+ constexpr LayoutTheme LAYOUT_HD_CALL
+ {"layout", "callui", "hd_voice"};
+
+
+ constexpr EdjePart PART_CONNECTION {"swl.connection"};
+ constexpr EdjePart PART_RSSI {"swl.rssi"};
+ constexpr EdjePart PART_BATTERY {"swl.battery"};
+ constexpr EdjePart PART_SIM {"swl.sim"};
+ constexpr EdjePart PART_HD_VOICE {"swl.hd_voice"};
+
+ constexpr EdjeSignal SIGL_BATT_LVL_HIDE {"batt_lvl_hide"};
+
+ EdjeSignal getConnUpdateSignal(ConnectionType connection)
+ {
+ switch (connection) {
+ case ConnectionType::EDGE_E: return EdjeSignal{"conn_edge_connected"};
+ case ConnectionType::GPRS_G: return EdjeSignal{"conn_gprs_connected"};
+ case ConnectionType::SIMPLE_2G: return EdjeSignal{"conn_2g_connected"};
+ case ConnectionType::HSDPA_H: return EdjeSignal{"conn_hsdpa_connected"};
+ case ConnectionType::HSPA_H_PLUS: return EdjeSignal{"conn_hspa_connected"};
+ case ConnectionType::LTE_4G: return EdjeSignal{"conn_lte_connected"};
+ case ConnectionType::UMTS_3G: return EdjeSignal{"conn_umts_connected"};
+ case ConnectionType::UMTS_3G_PLUS: return EdjeSignal{"conn_3g_plus_connected"};
+ case ConnectionType::WIFI_00: return EdjeSignal{"conn_wifi_connected_00"};
+ case ConnectionType::WIFI_01: return EdjeSignal{"conn_wifi_connected_01"};
+ case ConnectionType::WIFI_02: return EdjeSignal{"conn_wifi_connected_02"};
+ case ConnectionType::WIFI_03: return EdjeSignal{"conn_wifi_connected_03"};
+ case ConnectionType::WIFI_04: return EdjeSignal{"conn_wifi_connected_04"};
+ case ConnectionType::NO_SIGNAL: return EdjeSignal{"conn_no_signal"};
+ default: return EdjeSignal{"conn_none"};
+ }
+ }
+
+ EdjeSignal getPacketUpdateSignal(PacketDirection direction)
+ {
+ switch (direction) {
+ case PacketDirection::NO_INPUT: return EdjeSignal{"packet_no_inout_connected"};
+ case PacketDirection::IN: return EdjeSignal{"packet_in_connected"};
+ case PacketDirection::OUT: return EdjeSignal{"packet_out_connected"};
+ case PacketDirection::INOUT: return EdjeSignal{"packet_inout_connected"};
+ default: return EdjeSignal{"packet_none"};
+ }
+ }
+
+ EdjeSignal getRssiUpdateSignal(RssiState state, bool isRoaming)
+ {
+ switch (state) {
+ case RssiState::LEVEL_0: return EdjeSignal{ isRoaming ? "rssi_roaming_00" : "rssi_00"};
+ case RssiState::LEVEL_1: return EdjeSignal{ isRoaming ? "rssi_roaming_01" : "rssi_01"};
+ case RssiState::LEVEL_2: return EdjeSignal{ isRoaming ? "rssi_roaming_02" : "rssi_02"};
+ case RssiState::LEVEL_3: return EdjeSignal{ isRoaming ? "rssi_roaming_03" : "rssi_03"};
+ case RssiState::LEVEL_4: return EdjeSignal{ isRoaming ? "rssi_roaming_04" : "rssi_04"};
+ case RssiState::NO_SIGNAL: return EdjeSignal{"rssi_no_signal"};
+ case RssiState::FLIGHT_MODE: return EdjeSignal{"rssi_flight_mode"};
+ default: return EdjeSignal{"rssi_none"};
+ }
+ }
+
+ EdjeSignal getBatteryStateUpdateSignal(BatteryState state, int battLvl)
+ {
+ switch (state) {
+ case BatteryState::CHARGING: return EdjeSignal{"batt_state_charging"};
+ case BatteryState::CHARGING_PROBLEM: return EdjeSignal{"batt_state_charging_problem"};
+ case BatteryState::UNKNOWN: return EdjeSignal{"batt_state_unknown"};
+ default:
+ if (battLvl > BATTERY_LOW_LIMIT)
+ return EdjeSignal{"batt_state_normal"};
+ else
+ return EdjeSignal{"batt_state_low_battery"};
+ }
+ }
+
+ EdjeSignal getBatteryLevelUpdateSignal(int level, bool isLevelUnknown)
+ {
+ if (isLevelUnknown) {
+ return impl::SIGL_BATT_LVL_HIDE;
+ }
+
+ auto battLvl = level;
+ if (battLvl <= BATTERY_LOW_LIMIT) {
+ battLvl /= BATTERY_LOW_LIMIT;
+ battLvl *= BATTERY_LOW_LIMIT;
+ } else {
+ battLvl += BATTERY_LOW_LIMIT - 1;
+ battLvl /= BATTERY_LOW_LIMIT;
+ battLvl *= BATTERY_LOW_LIMIT;
+ }
+
+ if (battLvl <= BATTERY_LOW_LIMIT - 1) {
+ return impl::SIGL_BATT_LVL_HIDE;
+ }
+ return EdjeSignal{std::string("batt_lvl_").
+ append(std::to_string(battLvl)).
+ c_str()};
+
+ }
+
+ EdjeSignal getSimSlotUpdateSignal(SimSlot slot, bool isForwarded)
+ {
+ switch (slot) {
+ case SimSlot::GEAR:
+ if (isForwarded) {
+ return EdjeSignal{"sim_gear_forwarded"};
+ } else {
+ return EdjeSignal{"sim_gear"};
+ }
+ case SimSlot::MOBILE_DEFAULT: return EdjeSignal{"sim_mobile"};
+ case SimSlot::MOBILE_FIRST: return EdjeSignal{"sim_mobile_01"};
+ case SimSlot::MOBILE_SECOND: return EdjeSignal{"sim_mobile_02"};
+ default: return EdjeSignal{"sim_unknown"};
+ }
+ }
+
+}}}
+
+namespace callui {
+
+ using namespace ucl;
+
+ Indicator::Builder::Builder()
+ {
+ }
+
+ Indicator::Builder::~Builder()
+ {
+ }
+
+ Indicator::Builder &Indicator::Builder::setIndicatorStateProvider(
+ const IIndicatorStateProviderSRef &provider)
+ {
+ m_provider = provider;
+ return *this;
+ }
+
+ IndicatorSRef Indicator::Builder::build(ucl::ElmWidget &parent) const
+ {
+ if (!m_provider) {
+ LOG_RETURN_VALUE(RES_FAIL, {}, "Not all params are set");
+ }
+
+ auto result = makeShared<Indicator>(m_provider);
+ FAIL_RETURN_VALUE(result->prepare(parent), {},
+ "result->prepare() failed!");
+ return result;
+ }
+
+ Indicator::Indicator(ucl::RefCountObjBase &rc,
+ const IIndicatorStateProviderSRef &provider):
+ RefCountAware(&rc),
+ m_provider(provider)
+ {
+ }
+
+ Indicator::~Indicator()
+ {
+ }
+
+ Result Indicator::prepare(ucl::Widget &parent)
+ {
+ FAIL_RETURN(createWidget(parent),
+ "createWidget() failed!");
+
+ FAIL_RETURN(createConnectionLayout(),
+ "createConnectionLayout() failed!");
+
+ FAIL_RETURN(createRssiLayout(),
+ "createRssiLayout() failed!");
+
+ FAIL_RETURN(createBatteryLayout(),
+ "createBatteryLayout() failed!");
+
+ FAIL_RETURN(createSimLayout(),
+ "createSimLayout() failed!");
+
+ FAIL_RETURN(createHdVoiceLayout(),
+ "createHdCallLayout() failed!");
+
+ m_provider->setListener(asWeak(*this));
+
+ return RES_OK;
+ }
+
+ Result Indicator::createWidget(ucl::Widget &parent)
+ {
+ m_widget = Layout::Builder().
+ setTheme(impl::LAYOUT_INDICATOR_WIDGET).
+ setIsOwner(true).
+ build(parent);
+ if (!m_widget) {
+ LOG_RETURN(RES_FAIL, "Layout::build() failed!");
+ }
+
+ return RES_OK;
+ }
+
+ Result Indicator::createConnectionLayout()
+ {
+ m_connLayout = Layout::Builder().
+ setTheme(impl::LAYOUT_CONNECTION).
+ build(*m_widget);
+ if (!m_connLayout) {
+ LOG_RETURN(RES_FAIL, "Layout::build() failed!");
+ }
+ m_widget->setContent(*m_connLayout, impl::PART_CONNECTION);
+
+ updateConnectionState();
+
+ return RES_OK;
+ }
+
+ Result Indicator::createRssiLayout()
+ {
+ m_rssiLayout = Layout::Builder().
+ setTheme(impl::LAYOUT_RSSI).
+ build(*m_widget);
+ if (!m_rssiLayout) {
+ LOG_RETURN(RES_FAIL, "Layout::build() failed!");
+ }
+ m_widget->setContent(*m_rssiLayout, impl::PART_RSSI);
+
+ updateRssiState();
+
+ return RES_OK;
+ }
+
+ Result Indicator::createBatteryLayout()
+ {
+ m_batteryLayout = Layout::Builder().
+ setTheme(impl::LAYOUT_BATTERY).
+ build(*m_widget);
+ if (!m_batteryLayout) {
+ LOG_RETURN(RES_FAIL, "Layout::build() failed!");
+ }
+ m_widget->setContent(*m_batteryLayout, impl::PART_BATTERY);
+
+ updateBatteryState();
+
+ return RES_OK;
+ }
+
+ Result Indicator::createSimLayout()
+ {
+ m_simLayout = Layout::Builder().
+ setTheme(impl::LAYOUT_SIM).
+ build(*m_widget);
+ if (!m_simLayout) {
+ LOG_RETURN(RES_FAIL, "Layout::build() failed!");
+ }
+ m_widget->setContent(*m_simLayout, impl::PART_SIM);
+
+ updateSimState();
+
+ return RES_OK;
+ }
+
+ Result Indicator::createHdVoiceLayout()
+ {
+ m_hdCallLayout = Layout::Builder().
+ setTheme(impl::LAYOUT_HD_CALL).
+ build(*m_widget);
+ if (!m_hdCallLayout) {
+ LOG_RETURN(RES_FAIL, "Layout::build() failed!");
+ }
+ m_widget->setContent(*m_hdCallLayout, impl::PART_HD_VOICE);
+
+ updateHdVoiceState();
+
+ return RES_OK;
+ }
+
+ void Indicator::updateConnectionState()
+ {
+ auto state = m_provider->getState(IndicatorProperty::NW_CONNECTION);
+
+ m_connLayout->emit(impl::getConnUpdateSignal(
+ getConnectionState(state)));
+
+ m_connLayout->emit(impl::getPacketUpdateSignal(
+ getPacketDirection(state)));
+ }
+
+ void Indicator::updateRssiState()
+ {
+ auto state = m_provider->getState(IndicatorProperty::RSSI);
+
+ m_rssiLayout->emit(impl::getRssiUpdateSignal(
+ getRssiState(state),
+ getRoamingState(state)));
+ }
+
+ void Indicator::updateBatteryState()
+ {
+ auto state = m_provider->getState(IndicatorProperty::BATTERY);
+ auto battState = getBatteryState(state);
+ auto battLvl = getBatteryLevel(state);
+
+ m_batteryLayout->emit(
+ impl::getBatteryStateUpdateSignal(battState, battLvl));
+ m_batteryLayout->emit(
+ impl::getBatteryLevelUpdateSignal(battLvl,
+ (battState == BatteryState::UNKNOWN)));
+ }
+
+ void Indicator::updateSimState()
+ {
+ auto state = m_provider->getState(IndicatorProperty::SIM_SLOT);
+
+ m_simLayout->emit(impl::getSimSlotUpdateSignal(
+ getSimSlotType(state),
+ getSimForwardState(state)));
+ }
+
+ void Indicator::updateHdVoiceState()
+ {
+ auto state = m_provider->getState(IndicatorProperty::HD_VOICE);
+ m_hdCallLayout->emit(EdjeSignal{
+ (getHDVoiceState(state) ? "hd_voice_show" : "hd_voice_hide")});
+ }
+
+ Widget &Indicator::getWidget()
+ {
+ return *m_widget;
+ }
+
+ void Indicator::onStateChanged(IndicatorProperty property)
+ {
+ switch (property) {
+ case IndicatorProperty::NW_CONNECTION:
+ updateConnectionState();
+ break;
+ case IndicatorProperty::RSSI:
+ updateRssiState();
+ break;
+ case IndicatorProperty::BATTERY:
+ updateBatteryState();
+ break;
+ case IndicatorProperty::SIM_SLOT:
+ updateSimState();
+ break;
+ case IndicatorProperty::HD_VOICE:
+ updateHdVoiceState();
+ break;
+ default:
+ ELOG("Unhandled state");
+ return;
+ }
+ }
+
+}
#include "model/IActiveCall.h"
#include "model/IHeldCall.h"
#include "model/IEndCall.h"
+#include "model/IIndicatorStateProvider.h"
+#include "presenters/Indicator.h"
#include "presenters/AcceptRejectPresenter.h"
#include "common.h"
constexpr LayoutTheme LAYOUT_MAIN_WIDGET
{"layout", "callui", "main"};
+ constexpr EdjePart PART_SWL_INDICATOR {"swl.indicator"};
constexpr EdjePart PART_SWL_ACCEPT_REJECT {"swl.accept_reject"};
}}}
LOG_RETURN(RES_FAIL, "Layout::build() failed!");
}
+ m_indicator = Indicator::Builder().
+ setIndicatorStateProvider(m_call->getIndicatorStateProvider()).
+ build(*m_widget);
+ if (!m_indicator) {
+ LOG_RETURN(RES_FAIL, "Indicator::build() failed!");
+ }
+ m_widget->setContent(m_indicator->getWidget().getEo(), impl::PART_SWL_INDICATOR);
+
return Page::prepare([this]() {
return getNaviframe().
push(*m_widget);
projects / profile / wearable / apps / native / call-ui.git / commitdiff
