1/*
2 * Copyright (C) 2017 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <binder/IServiceManager.h>
18#include <media/PlayerBase.h>
19
20#define max(a, b) ((a) > (b) ? (a) : (b))
21#define min(a, b) ((a) < (b) ? (a) : (b))
22
23namespace android {
24
25using media::VolumeShaper;
26
27//--------------------------------------------------------------------------------------------------
28PlayerBase::PlayerBase() : BnPlayer(),
29        mPanMultiplierL(1.0f), mPanMultiplierR(1.0f),
30        mVolumeMultiplierL(1.0f), mVolumeMultiplierR(1.0f),
31        mPIId(PLAYER_PIID_INVALID), mLastReportedEvent(PLAYER_STATE_UNKNOWN)
32{
33    ALOGD("PlayerBase::PlayerBase()");
34    // use checkService() to avoid blocking if audio service is not up yet
35    sp<IBinder> binder = defaultServiceManager()->checkService(String16("audio"));
36    if (binder == 0) {
37        ALOGE("PlayerBase(): binding to audio service failed, service up?");
38    } else {
39        mAudioManager = interface_cast<IAudioManager>(binder);
40    }
41}
42
43
44PlayerBase::~PlayerBase() {
45    ALOGD("PlayerBase::~PlayerBase()");
46    baseDestroy();
47}
48
49void PlayerBase::init(player_type_t playerType, audio_usage_t usage) {
50    if (mAudioManager == 0) {
51                ALOGE("AudioPlayer realize: no audio service, player will not be registered");
52    } else {
53        mPIId = mAudioManager->trackPlayer(playerType, usage, AUDIO_CONTENT_TYPE_UNKNOWN, this);
54    }
55}
56
57void PlayerBase::baseDestroy() {
58    serviceReleasePlayer();
59    if (mAudioManager != 0) {
60        mAudioManager.clear();
61    }
62}
63
64//------------------------------------------------------------------------------
65void PlayerBase::servicePlayerEvent(player_state_t event) {
66    if (mAudioManager != 0) {
67        // only report state change
68        Mutex::Autolock _l(mPlayerStateLock);
69        if (event != mLastReportedEvent
70                && mPIId != PLAYER_PIID_INVALID) {
71            mLastReportedEvent = event;
72            mAudioManager->playerEvent(mPIId, event);
73        }
74    }
75}
76
77void PlayerBase::serviceReleasePlayer() {
78    if (mAudioManager != 0
79            && mPIId != PLAYER_PIID_INVALID) {
80        mAudioManager->releasePlayer(mPIId);
81    }
82}
83
84//FIXME temporary method while some player state is outside of this class
85void PlayerBase::reportEvent(player_state_t event) {
86    servicePlayerEvent(event);
87}
88
89status_t PlayerBase::startWithStatus() {
90    status_t status = playerStart();
91    if (status == NO_ERROR) {
92        servicePlayerEvent(PLAYER_STATE_STARTED);
93    } else {
94        ALOGW("PlayerBase::start() error %d", status);
95    }
96    return status;
97}
98
99status_t PlayerBase::pauseWithStatus() {
100    status_t status = playerPause();
101    if (status == NO_ERROR) {
102        servicePlayerEvent(PLAYER_STATE_PAUSED);
103    } else {
104        ALOGW("PlayerBase::pause() error %d", status);
105    }
106    return status;
107}
108
109
110status_t PlayerBase::stopWithStatus() {
111    status_t status = playerStop();
112    if (status == NO_ERROR) {
113        servicePlayerEvent(PLAYER_STATE_STOPPED);
114    } else {
115        ALOGW("PlayerBase::stop() error %d", status);
116    }
117    return status;
118}
119
120//------------------------------------------------------------------------------
121// Implementation of IPlayer
122binder::Status PlayerBase::start() {
123    ALOGD("PlayerBase::start() from IPlayer");
124    (void)startWithStatus();
125    return binder::Status::ok();
126}
127
128binder::Status PlayerBase::pause() {
129    ALOGD("PlayerBase::pause() from IPlayer");
130    (void)pauseWithStatus();
131    return binder::Status::ok();
132}
133
134
135binder::Status PlayerBase::stop() {
136    ALOGD("PlayerBase::stop() from IPlayer");
137    (void)stopWithStatus();
138    return binder::Status::ok();
139}
140
141binder::Status PlayerBase::setVolume(float vol) {
142    ALOGD("PlayerBase::setVolume() from IPlayer");
143    {
144        Mutex::Autolock _l(mSettingsLock);
145        mVolumeMultiplierL = vol;
146        mVolumeMultiplierR = vol;
147    }
148    status_t status = playerSetVolume();
149    if (status != NO_ERROR) {
150        ALOGW("PlayerBase::setVolume() error %d", status);
151    }
152    return binder::Status::fromStatusT(status);
153}
154
155binder::Status PlayerBase::setPan(float pan) {
156    ALOGD("PlayerBase::setPan() from IPlayer");
157    {
158        Mutex::Autolock _l(mSettingsLock);
159        pan = min(max(-1.0f, pan), 1.0f);
160        if (pan >= 0.0f) {
161            mPanMultiplierL = 1.0f - pan;
162            mPanMultiplierR = 1.0f;
163        } else {
164            mPanMultiplierL = 1.0f;
165            mPanMultiplierR = 1.0f + pan;
166        }
167    }
168    status_t status = playerSetVolume();
169    if (status != NO_ERROR) {
170        ALOGW("PlayerBase::setPan() error %d", status);
171    }
172    return binder::Status::fromStatusT(status);
173}
174
175binder::Status PlayerBase::setStartDelayMs(int32_t delayMs __unused) {
176    ALOGW("setStartDelay() is not supported");
177    return binder::Status::ok();
178}
179
180binder::Status PlayerBase::applyVolumeShaper(
181            const VolumeShaper::Configuration& configuration __unused,
182            const VolumeShaper::Operation& operation __unused) {
183    ALOGW("applyVolumeShaper() is not supported");
184    return binder::Status::ok();
185}
186
187} // namespace android
188