1 /*
2 * Copyright (c) 2022 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 "AudioClientTrackerCallbackStub"
17 #endif
18
19 #include "audio_client_tracker_callback_stub.h"
20 #include "audio_policy_log.h"
21
22 namespace OHOS {
23 namespace AudioStandard {
AudioClientTrackerCallbackStub()24 AudioClientTrackerCallbackStub::AudioClientTrackerCallbackStub()
25 {
26 }
27
~AudioClientTrackerCallbackStub()28 AudioClientTrackerCallbackStub::~AudioClientTrackerCallbackStub()
29 {
30 }
31
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)32 int AudioClientTrackerCallbackStub::OnRemoteRequest(
33 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
34 {
35 CHECK_AND_RETURN_RET_LOG(data.ReadInterfaceToken() == GetDescriptor(), -1,
36 "AudioClientTrackerCallbackStub: ReadInterfaceToken failed");
37
38 switch (code) {
39 case PAUSEDSTREAM: {
40 StreamSetStateEventInternal sreamSetStateEventInternal = {};
41 sreamSetStateEventInternal.streamSetState= static_cast<StreamSetState>(data.ReadInt32());
42 sreamSetStateEventInternal.streamUsage = static_cast<StreamUsage>(data.ReadInt32());
43 PausedStreamImpl(sreamSetStateEventInternal);
44 return AUDIO_OK;
45 }
46 case RESUMESTREAM: {
47 StreamSetStateEventInternal sreamSetStateEventInternal = {};
48 sreamSetStateEventInternal.streamSetState= static_cast<StreamSetState>(data.ReadInt32());
49 sreamSetStateEventInternal.streamUsage = static_cast<StreamUsage>(data.ReadInt32());
50 ResumeStreamImpl(sreamSetStateEventInternal);
51 return AUDIO_OK;
52 }
53 case SETLOWPOWERVOL: {
54 float volume = data.ReadFloat();
55 SetLowPowerVolumeImpl(volume);
56 return AUDIO_OK;
57 }
58 case GETLOWPOWERVOL: {
59 float volume;
60 GetLowPowerVolumeImpl(volume);
61 reply.WriteFloat(volume);
62 return AUDIO_OK;
63 }
64 case GETSINGLESTREAMVOL: {
65 float volume;
66 GetSingleStreamVolumeImpl(volume);
67 reply.WriteFloat(volume);
68 return AUDIO_OK;
69 }
70 case SETOFFLOADMODE:
71 case UNSETOFFLOADMODE: {
72 return OffloadRemoteRequest(code, data, reply, option);
73 }
74 default: {
75 AUDIO_ERR_LOG("default case, need check AudioListenerStub");
76 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
77 }
78 }
79
80 return 0;
81 }
82
OffloadRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)83 int AudioClientTrackerCallbackStub::OffloadRemoteRequest(
84 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
85 {
86 if (code == SETOFFLOADMODE) {
87 int32_t state = data.ReadInt32();
88 bool isAppBack = data.ReadBool();
89 SetOffloadModeImpl(state, isAppBack);
90 return AUDIO_OK;
91 }
92
93 if (code == UNSETOFFLOADMODE) {
94 UnsetOffloadModeImpl();
95 return AUDIO_OK;
96 }
97 return 0;
98 }
99
SetClientTrackerCallback(const std::weak_ptr<AudioClientTracker> & callback)100 void AudioClientTrackerCallbackStub::SetClientTrackerCallback(
101 const std::weak_ptr<AudioClientTracker> &callback)
102 {
103 callback_ = callback;
104 }
105
PausedStreamImpl(const StreamSetStateEventInternal & streamSetStateEventInternal)106 void AudioClientTrackerCallbackStub::PausedStreamImpl(
107 const StreamSetStateEventInternal &streamSetStateEventInternal)
108 {
109 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
110 if (cb != nullptr) {
111 cb->PausedStreamImpl(streamSetStateEventInternal);
112 } else {
113 AUDIO_WARNING_LOG("AudioClientTrackerCallbackStub: PausedStreamImpl callback_ is nullptr");
114 }
115 }
116
SetLowPowerVolumeImpl(float volume)117 void AudioClientTrackerCallbackStub::SetLowPowerVolumeImpl(float volume)
118 {
119 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
120 if (cb != nullptr) {
121 cb->SetLowPowerVolumeImpl(volume);
122 } else {
123 AUDIO_WARNING_LOG("AudioClientTrackerCallbackStub: SetLowPowerVolumeImpl callback_ is nullptr");
124 }
125 }
126
ResumeStreamImpl(const StreamSetStateEventInternal & streamSetStateEventInternal)127 void AudioClientTrackerCallbackStub::ResumeStreamImpl(
128 const StreamSetStateEventInternal &streamSetStateEventInternal)
129 {
130 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
131 if (cb != nullptr) {
132 cb->ResumeStreamImpl(streamSetStateEventInternal);
133 } else {
134 AUDIO_WARNING_LOG("AudioClientTrackerCallbackStub: ResumeStreamImpl callback_ is nullptr");
135 }
136 }
137
SetOffloadModeImpl(int32_t state,bool isAppBack)138 void AudioClientTrackerCallbackStub::SetOffloadModeImpl(int32_t state, bool isAppBack)
139 {
140 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
141 if (cb != nullptr) {
142 cb->SetOffloadModeImpl(state, isAppBack);
143 } else {
144 AUDIO_WARNING_LOG("AudioClientTrackerCallbackStub: SetOffloadModeImpl callback_ is nullptr");
145 }
146 }
147
UnsetOffloadModeImpl()148 void AudioClientTrackerCallbackStub::UnsetOffloadModeImpl()
149 {
150 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
151 if (cb != nullptr) {
152 cb->UnsetOffloadModeImpl();
153 } else {
154 AUDIO_WARNING_LOG("AudioClientTrackerCallbackStub: UnsetOffloadModeImpl callback_ is nullptr");
155 }
156 }
157
GetLowPowerVolumeImpl(float & volume)158 void AudioClientTrackerCallbackStub::GetLowPowerVolumeImpl(float &volume)
159 {
160 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
161 if (cb != nullptr) {
162 cb->GetLowPowerVolumeImpl(volume);
163 } else {
164 AUDIO_WARNING_LOG("AudioClientTrackerCallbackStub: GetLowPowerVolumeImpl callback_ is nullptr");
165 }
166 }
167
GetSingleStreamVolumeImpl(float & volume)168 void AudioClientTrackerCallbackStub::GetSingleStreamVolumeImpl(float &volume)
169 {
170 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
171 if (cb != nullptr) {
172 cb->GetSingleStreamVolumeImpl(volume);
173 } else {
174 AUDIO_WARNING_LOG("AudioClientTrackerCallbackStub: GetSingleStreamVolumeImpl callback_ is nullptr");
175 }
176 }
177 } // namespace AudioStandard
178 } // namespace OHOS
179