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
16 #include "audio_client_tracker_callback_stub.h"
17 #include "audio_log.h"
18
19 namespace OHOS {
20 namespace AudioStandard {
AudioClientTrackerCallbackStub()21 AudioClientTrackerCallbackStub::AudioClientTrackerCallbackStub()
22 {
23 }
24
~AudioClientTrackerCallbackStub()25 AudioClientTrackerCallbackStub::~AudioClientTrackerCallbackStub()
26 {
27 }
28
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)29 int AudioClientTrackerCallbackStub::OnRemoteRequest(
30 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
31 {
32 AUDIO_DEBUG_LOG("AudioClientTrackerCallbackStub::OnRemoteRequest");
33 if (data.ReadInterfaceToken() != GetDescriptor()) {
34 AUDIO_ERR_LOG("AudioClientTrackerCallbackStub: ReadInterfaceToken failed");
35 return -1;
36 }
37
38 switch (code) {
39 case PAUSEDSTREAM: {
40 StreamSetStateEventInternal sreamSetStateEventInternal = {};
41 sreamSetStateEventInternal.streamSetState= static_cast<StreamSetState>(data.ReadInt32());
42 sreamSetStateEventInternal.audioStreamType = static_cast<AudioStreamType>(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.audioStreamType = static_cast<AudioStreamType>(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 default: {
71 AUDIO_ERR_LOG("default case, need check AudioListenerStub");
72 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
73 }
74 }
75
76 return 0;
77 }
78
SetClientTrackerCallback(const std::weak_ptr<AudioClientTracker> & callback)79 void AudioClientTrackerCallbackStub::SetClientTrackerCallback(
80 const std::weak_ptr<AudioClientTracker> &callback)
81 {
82 AUDIO_DEBUG_LOG("AudioClientTrackerCallbackStub::SetClientTrackerCallback");
83 callback_ = callback;
84 }
85
PausedStreamImpl(const StreamSetStateEventInternal & streamSetStateEventInternal)86 void AudioClientTrackerCallbackStub::PausedStreamImpl(
87 const StreamSetStateEventInternal &streamSetStateEventInternal)
88 {
89 AUDIO_DEBUG_LOG("AudioClientTrackerCallbackStub PausedStreamImpl start");
90 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
91 if (cb != nullptr) {
92 cb->PausedStreamImpl(streamSetStateEventInternal);
93 } else {
94 AUDIO_ERR_LOG("AudioClientTrackerCallbackStub: PausedStreamImpl callback_ is nullptr");
95 }
96 }
97
SetLowPowerVolumeImpl(float volume)98 void AudioClientTrackerCallbackStub::SetLowPowerVolumeImpl(float volume)
99 {
100 AUDIO_DEBUG_LOG("AudioClientTrackerCallbackStub SetLowPowerVolumeImpl start");
101 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
102 if (cb != nullptr) {
103 cb->SetLowPowerVolumeImpl(volume);
104 } else {
105 AUDIO_ERR_LOG("AudioClientTrackerCallbackStub: SetLowPowerVolumeImpl callback_ is nullptr");
106 }
107 }
108
ResumeStreamImpl(const StreamSetStateEventInternal & streamSetStateEventInternal)109 void AudioClientTrackerCallbackStub::ResumeStreamImpl(
110 const StreamSetStateEventInternal &streamSetStateEventInternal)
111 {
112 AUDIO_DEBUG_LOG("AudioClientTrackerCallbackStub ResumeStreamImpl start");
113 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
114 if (cb != nullptr) {
115 cb->ResumeStreamImpl(streamSetStateEventInternal);
116 } else {
117 AUDIO_ERR_LOG("AudioClientTrackerCallbackStub: ResumeStreamImpl callback_ is nullptr");
118 }
119 }
120
GetLowPowerVolumeImpl(float & volume)121 void AudioClientTrackerCallbackStub::GetLowPowerVolumeImpl(float &volume)
122 {
123 AUDIO_DEBUG_LOG("AudioClientTrackerCallbackStub GetLowPowerVolumeImpl start");
124 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
125 if (cb != nullptr) {
126 cb->GetLowPowerVolumeImpl(volume);
127 } else {
128 AUDIO_ERR_LOG("AudioClientTrackerCallbackStub: GetLowPowerVolumeImpl callback_ is nullptr");
129 }
130 }
131
GetSingleStreamVolumeImpl(float & volume)132 void AudioClientTrackerCallbackStub::GetSingleStreamVolumeImpl(float &volume)
133 {
134 AUDIO_DEBUG_LOG("AudioClientTrackerCallbackStub GetSingleStreamVolumeImpl start");
135 std::shared_ptr<AudioClientTracker> cb = callback_.lock();
136 if (cb != nullptr) {
137 cb->GetSingleStreamVolumeImpl(volume);
138 } else {
139 AUDIO_ERR_LOG("AudioClientTrackerCallbackStub: GetSingleStreamVolumeImpl callback_ is nullptr");
140 }
141 }
142 } // namespace AudioStandard
143 } // namespace OHOS
144