1 /*
2 * Copyright (c) 2023-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #ifndef LOG_TAG
16 #define LOG_TAG "PowerStateListener"
17 #endif
18
19 #include "power_state_listener.h"
20
21 #include "suspend/sync_sleep_callback_ipc_interface_code.h"
22 #include "hibernate/sync_hibernate_callback_ipc_interface_code.h"
23 #include "audio_policy_server.h"
24
25 namespace OHOS {
26 namespace AudioStandard {
27 using namespace std::chrono_literals;
28 const int32_t AUDIO_INTERRUPT_SESSION_ID = 10000;
29
InitAudioInterruptInfo(AudioInterrupt & audioInterrupt)30 void PowerListerMethods::InitAudioInterruptInfo(AudioInterrupt& audioInterrupt)
31 {
32 audioInterrupt.contentType = ContentType::CONTENT_TYPE_UNKNOWN;
33 audioInterrupt.streamUsage = StreamUsage::STREAM_USAGE_UNKNOWN;
34 audioInterrupt.audioFocusType.streamType = AudioStreamType::STREAM_INTERNAL_FORCE_STOP;
35 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
36 audioInterrupt.audioFocusType.isPlay = true;
37 audioInterrupt.sessionId = AUDIO_INTERRUPT_SESSION_ID;
38 audioInterrupt.pid = getpid();
39 }
40
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)41 int32_t PowerStateListenerStub::OnRemoteRequest(uint32_t code, MessageParcel &data,
42 MessageParcel &reply, MessageOption &option)
43 {
44 AUDIO_DEBUG_LOG("code = %{public}d, flag = %{public}d", code, option.GetFlags());
45 std::u16string descriptor = PowerStateListenerStub::GetDescriptor();
46 std::u16string remoteDescriptor = data.ReadInterfaceToken();
47 CHECK_AND_RETURN_RET_LOG(descriptor == remoteDescriptor, -1, "Descriptor not match");
48
49 int32_t ret = ERR_OK;
50 switch (code) {
51 case static_cast<int32_t>(PowerMgr::SyncSleepCallbackInterfaceCode::CMD_ON_SYNC_SLEEP):
52 ret = OnSyncSleepCallbackStub(data);
53 break;
54 case static_cast<int32_t>(PowerMgr::SyncSleepCallbackInterfaceCode::CMD_ON_SYNC_WAKEUP):
55 ret = OnSyncWakeupCallbackStub(data);
56 break;
57 default:
58 ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option);
59 break;
60 }
61
62 return ret;
63 }
64
OnSyncSleepCallbackStub(MessageParcel & data)65 int32_t PowerStateListenerStub::OnSyncSleepCallbackStub(MessageParcel &data)
66 {
67 bool forceSleep = data.ReadBool();
68 OnSyncSleep(forceSleep);
69
70 return ERR_OK;
71 }
72
OnSyncWakeupCallbackStub(MessageParcel & data)73 int32_t PowerStateListenerStub::OnSyncWakeupCallbackStub(MessageParcel &data)
74 {
75 bool forceSleep = data.ReadBool();
76 OnSyncWakeup(forceSleep);
77
78 return ERR_OK;
79 }
80
PowerStateListener(const sptr<AudioPolicyServer> audioPolicyServer)81 PowerStateListener::PowerStateListener(const sptr<AudioPolicyServer> audioPolicyServer)
82 : audioPolicyServer_(audioPolicyServer) {}
83
OnSyncSleep(bool OnForceSleep)84 void PowerStateListener::OnSyncSleep(bool OnForceSleep)
85 {
86 CHECK_AND_RETURN_LOG(OnForceSleep, "OnSyncSleep not force sleep");
87
88 ControlAudioFocus(true);
89 }
90
OnSyncWakeup(bool OnForceSleep)91 void PowerStateListener::OnSyncWakeup(bool OnForceSleep)
92 {
93 CHECK_AND_RETURN_LOG(OnForceSleep, "OnSyncWakeup not force sleep");
94
95 ControlAudioFocus(false);
96 }
97
ControlAudioFocus(bool applyFocus)98 void PowerStateListener::ControlAudioFocus(bool applyFocus)
99 {
100 AudioInterrupt audioInterrupt;
101 PowerListerMethods::InitAudioInterruptInfo(audioInterrupt);
102
103 int32_t result = -1;
104 if (applyFocus) {
105 result = audioPolicyServer_->ActivateAudioInterrupt(audioInterrupt);
106 if (result != SUCCESS) {
107 AUDIO_WARNING_LOG("Activate audio interrupt failed, err = %{public}d", result);
108 }
109 } else {
110 result = audioPolicyServer_->DeactivateAudioInterrupt(audioInterrupt);
111 if (result != SUCCESS) {
112 AUDIO_WARNING_LOG("Deactivate audio interrupt failed, err = %{public}d", result);
113 }
114 }
115 }
116
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)117 int32_t SyncHibernateListenerStub::OnRemoteRequest(uint32_t code, MessageParcel &data,
118 MessageParcel &reply, MessageOption &option)
119 {
120 AUDIO_DEBUG_LOG("code = %{public}d, flag = %{public}d", code, option.GetFlags());
121 std::u16string descriptor = SyncHibernateListenerStub::GetDescriptor();
122 std::u16string remoteDescriptor = data.ReadInterfaceToken();
123 CHECK_AND_RETURN_RET_LOG(descriptor == remoteDescriptor, -1, "Descriptor not match");
124
125 int32_t ret = ERR_OK;
126 switch (code) {
127 case static_cast<int32_t>(PowerMgr::SyncHibernateCallbackInterfaceCode::CMD_ON_SYNC_HIBERNATE):
128 ret = OnSyncHibernateCallbackStub();
129 break;
130 case static_cast<int32_t>(PowerMgr::SyncHibernateCallbackInterfaceCode::CMD_ON_SYNC_WAKEUP):
131 ret = OnSyncWakeupCallbackStub();
132 break;
133 default:
134 ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option);
135 break;
136 }
137
138 return ret;
139 }
140
OnSyncHibernateCallbackStub()141 int32_t SyncHibernateListenerStub::OnSyncHibernateCallbackStub()
142 {
143 OnSyncHibernate();
144
145 return ERR_OK;
146 }
147
OnSyncWakeupCallbackStub()148 int32_t SyncHibernateListenerStub::OnSyncWakeupCallbackStub()
149 {
150 OnSyncWakeup();
151
152 return ERR_OK;
153 }
154
SyncHibernateListener(const sptr<AudioPolicyServer> audioPolicyServer)155 SyncHibernateListener::SyncHibernateListener(const sptr<AudioPolicyServer> audioPolicyServer)
156 : audioPolicyServer_(audioPolicyServer) {}
157
OnSyncHibernate()158 void SyncHibernateListener::OnSyncHibernate()
159 {
160 AUDIO_INFO_LOG("OnSyncHibernate in hibernate");
161 ControlAudioFocus(true);
162 }
163
OnSyncWakeup()164 void SyncHibernateListener::OnSyncWakeup()
165 {
166 AUDIO_INFO_LOG("OnSyncWakeup in hibernate");
167 ControlAudioFocus(false);
168 }
169
ControlAudioFocus(bool isHibernate)170 void SyncHibernateListener::ControlAudioFocus(bool isHibernate)
171 {
172 AudioInterrupt audioInterrupt;
173 PowerListerMethods::InitAudioInterruptInfo(audioInterrupt);
174
175 int32_t result = -1;
176 if (isHibernate) {
177 result = audioPolicyServer_->ActivateAudioInterrupt(audioInterrupt);
178 if (result != SUCCESS) {
179 AUDIO_WARNING_LOG("Sync hibernate activate audio interrupt failed, err = %{public}d", result);
180 }
181 } else {
182 result = audioPolicyServer_->DeactivateAudioInterrupt(audioInterrupt);
183 if (result != SUCCESS) {
184 AUDIO_WARNING_LOG("Sync hibernate deactivate audio interrupt failed, err = %{public}d", result);
185 }
186 }
187 }
188 } // namespace AudioStandard
189 } // namespace OHOS
190