static int set_normal_path(struct codec_client *client, int path)
{
int headset_on=0, headphone_on=0, speaker_on=0, earpiece_on=0;
headset_on = path & AUDIO_DEVICE_OUT_WIRED_HEADSET; // hp4p
headphone_on = path & AUDIO_DEVICE_OUT_WIRED_HEADPHONE; // hp3p
speaker_on = path & AUDIO_DEVICE_OUT_SPEAKER;
earpiece_on = path & AUDIO_DEVICE_OUT_EARPIECE;
if(wake_lock){
releaseWakeLock();
wake_lock=false;
}
if ((headset_on || headphone_on) && speaker_on){
ALOGV("in normal mode, headset and speaker on,****LINE:%d,FUNC:%s",__LINE__,__FUNCTION__);
mixer_ctl_set_enum_by_string(client->mixer_ctls->audio_spk_headset_switch, "headset-spk");
// } else if(earpiece_on && (no_earpiece!=1)) {
// mixer_ctl_set_enum_by_string(client->mixer_ctls->audio_spk_headset_switch, "earpiece");// "spk" : "headset");
// ALOGV("in normal mode, earpiece on,****LINE:%d,FUNC:%s",__LINE__,__FUNCTION__);
} else if(headset_on | headphone_on) {
mixer_ctl_set_enum_by_string(client->mixer_ctls->audio_spk_headset_switch, "headset");
ALOGV("in normal mode, headset on,****LINE:%d,FUNC:%s",__LINE__,__FUNCTION__);
} else {
ALOGV("in normal mode, speaker on,****LINE:%d,FUNC:%s, speaker_on=%d", __LINE__,__FUNCTION__, speaker_on);
mixer_ctl_set_enum_by_string(client->mixer_ctls->audio_spk_headset_switch, "spk" );
}
return 0;
}
static int set_normal_path(struct codec_client *client, int path)
{
int headset_on=0, headphone_on=0, speaker_on=0, earpiece_on=0;
headset_on = path & AUDIO_DEVICE_OUT_WIRED_HEADSET; // hp4p
headphone_on = path & AUDIO_DEVICE_OUT_WIRED_HEADPHONE; // hp3p
speaker_on = path & AUDIO_DEVICE_OUT_SPEAKER;
earpiece_on = path & AUDIO_DEVICE_OUT_EARPIECE;
if (g_is_bp_thread_running){
g_is_bp_thread_running = false;
plan_two_stop_voice();
mixer_ctl_set_value(client->mixer_ctls->audio_phone_end_call, 0, 1);
}
if(last_path_is_bt){
last_path_is_bt = false;
plan_two_stop_bt_voice();
mixer_ctl_set_value(client->mixer_ctls->audio_phone_end_call, 0, 1);
}
if(wake_lock){
releaseWakeLock();
wake_lock=false;
}
mixer_ctl_set_value(client->mixer_ctls->audio_linein_in, 0, 0); //turn off fm
if ((headset_on || headphone_on) && speaker_on){
ALOGV("in normal mode, headset and speaker on,****LINE:%d,FUNC:%s",__LINE__,__FUNCTION__);
mixer_ctl_set_enum_by_string(client->mixer_ctls->audio_spk_headset_switch, "spk_headset");
} else if(earpiece_on && (no_earpiece!=1)) {
mixer_ctl_set_enum_by_string(client->mixer_ctls->audio_spk_headset_switch, "earpiece");// "spk" : "headset");
ALOGV("in normal mode, earpiece on,****LINE:%d,FUNC:%s",__LINE__,__FUNCTION__);
} else if(headset_on | headphone_on) {
mixer_ctl_set_enum_by_string(client->mixer_ctls->audio_spk_headset_switch, "headset");
ALOGV("in normal mode, headset on,****LINE:%d,FUNC:%s",__LINE__,__FUNCTION__);
} else {
ALOGV("in normal mode, speaker on,****LINE:%d,FUNC:%s, speaker_on=%d", __LINE__,__FUNCTION__, speaker_on);
mixer_ctl_set_enum_by_string(client->mixer_ctls->audio_spk_headset_switch, "spk" );
}
return 0;
}
TunnelPlayer::~TunnelPlayer() {
ALOGD("TunnelPlayer::~TunnelPlayer()");
if (mQueueStarted) {
mQueue.stop();
}
reset();
//mAudioFlinger->deregisterClient(mAudioFlingerClient);
mTunnelObjectsAlive--;
releaseWakeLock();
if (mPowerManager != 0) {
sp<IBinder> binder = mPowerManager->asBinder();
binder->unlinkToDeath(mDeathRecipient);
}
}
static void* svc_context(void *__u)
{
SVCXPRT *xprt = (SVCXPRT *)__u;
int n;
struct timeval tv;
volatile fd_set rfds;
while(xprt->num_servers) {
rfds = xprt->fdset;
tv.tv_sec = 1; tv.tv_usec = 0;
n = select(xprt->max_fd + 1, (fd_set *)&rfds, NULL, NULL, &tv);
if (n < 0) {
E("select() error %s (%d)\n", strerror(errno), errno);
continue;
}
if (n) {
grabPartialWakeLock();
for (n = 0; n <= xprt->max_fd; n++) {
if (FD_ISSET(n, &rfds)) {
/* the file descriptor points to the service instance; we
simply look that service by its file descriptor, and
call its service function. */
/* FIXME: need to take xprt->lock */
registered_server *trav = xprt->servers;
for (; trav; trav = trav->next)
if ((trav->xdr) && (trav->xdr->fd == n)) {
/* read the entire RPC */
if (trav->xdr->xops->read(trav->xdr) == 0) {
E("%08x:%08x ONCRPC read error: aborting!\n",
trav->xdr->x_prog, trav->xdr->x_vers);
abort();
}
svc_dispatch(trav, xprt);
break;
}
} /* if fd is set */
} /* for each fd */
releaseWakeLock();
}
}
D("RPC-server thread exiting!\n");
return NULL;
}
void TunnelPlayer::onPauseTimeOut() {
ALOGV("onPauseTimeOut");
if (!mPauseEventPending) {
return;
}
mPauseEventPending = false;
if(!mIsA2DPEnabled) {
// 1.) Set seek flags
mReachedEOS = false;
mReachedOutputEOS = false;
mSeekTimeUs += getTimeStamp(A2DP_DISABLED);
// 2.) Close routing Session
mAudioSink->close();
mIsAudioRouted = false;
// 3.) Release Wake Lock
releaseWakeLock();
}
}
void TunnelPlayer::clearPowerManager()
{
Mutex::Autolock _l(pmLock);
releaseWakeLock();
mPowerManager.clear();
}
void callkey_wakelock_timer_fun(unsigned long data)
{
struct call_key_workdata *ck_workdata=(struct call_key_workdata *)data;
releaseWakeLock(ck_workdata);
}
/* There's one of these for each RPC client which has received an RPC call. */
static void *cb_context(void *__u)
{
CLIENT *client = (CLIENT *)__u;
D("RPC-callback thread for %08x:%08x starting.\n",
(client->xdr->x_prog | 0x01000000),
client->xdr->x_vers);
pthread_mutex_lock(&client->wait_cb_lock);
while (client->cb_stop == 0) {
if (!client->got_cb)
pthread_cond_wait(&client->wait_cb,
&client->wait_cb_lock);
/* We tell the thread it's time to exit by setting cb_stop to nonzero
and signalling the conditional variable. When there's no data, we
skip to the top of the loop and exit.
*/
if (!client->got_cb) {
D("RPC-callback thread for %08x:%08x: signalled but no data.\n",
(client->xdr->x_prog | 0x01000000),
client->xdr->x_vers);
continue;
}
client->got_cb = 0;
/* We dispatch the message to the server representing the callback
* client.
*/
if (the_xprt) {
void *svc;
rpcprog_t prog =
ntohl(((uint32 *)(client->xdr->in_msg))[RPC_OFFSET+3]);
rpcvers_t vers =
ntohl(((uint32 *)(client->xdr->in_msg))[RPC_OFFSET+4]);
svc = svc_find(the_xprt, prog, vers);
if (svc) {
XDR **svc_xdr = (XDR **)svc;
D("%08x:%08x dispatching RPC call (XID %d, xdr %p) for "
"callback client %08x:%08x.\n",
client->xdr->x_prog,
client->xdr->x_vers,
ntohl(((uint32 *)(client->xdr->in_msg))[RPC_OFFSET]),
client->xdr,
(uint32_t)prog, (int)vers);
/* We transplant the xdr of the client into the entry
representing the callback client in the list of servers.
Note that since we hold the wait_cb_lock for this client,
if another call for this callback client arrives before
we've finished processing this call, that will block until
we're done with this one. If this happens, it would be
most likely a bug in the arm9 rpc router.
*/
if (*svc_xdr) {
D("%08x:%08x expecting XDR == NULL"
"callback client %08x:%08x!\n",
client->xdr->x_prog,
client->xdr->x_vers,
(uint32_t)prog, (int)vers);
xdr_destroy_common(*svc_xdr);
}
/* Do these checks before the clone */
if (client->xdr->in_len < 0) {
E("%08x:%08x xdr->in_len = %i error %s (%d)",
client->xdr->in_len,
client->xdr->x_prog, client->xdr->x_vers,
strerror(errno), errno);
continue;
}
if (client->xdr->out_next < 0) {
E("%08x:%08x xdr->out_next = %i error %s (%d)",
client->xdr->out_next,
client->xdr->x_prog, client->xdr->x_vers,
strerror(errno), errno);
continue;
}
D("%08x:%08x cloning XDR for "
"callback client %08x:%08x.\n",
client->xdr->x_prog,
client->xdr->x_vers,
(uint32_t)prog, (int)vers);
*svc_xdr = xdr_clone(client->xdr);
(*svc_xdr)->x_prog = prog;
(*svc_xdr)->x_vers = vers;
memcpy((*svc_xdr)->in_msg,
client->xdr->in_msg, client->xdr->in_len);
memcpy((*svc_xdr)->out_msg,
client->xdr->out_msg, client->xdr->out_next);
(*svc_xdr)->in_len = client->xdr->in_len;
(*svc_xdr)->out_next = client->xdr->out_next;
pthread_mutex_lock(&client->input_xdr_lock);
D("%08x:%08x marking input buffer as free.\n",
client->xdr->x_prog, client->xdr->x_vers);
client->input_xdr_busy = 0;
pthread_cond_signal(&client->input_xdr_wait);
pthread_mutex_unlock(&client->input_xdr_lock);
svc_dispatch(svc, the_xprt);
xdr_destroy_common(*svc_xdr);
*svc_xdr = NULL;
}
else E("%08x:%08x call packet arrived, but there's no "
"RPC server registered for %08x:%08x.\n",
client->xdr->x_prog,
client->xdr->x_vers,
(uint32_t)prog, (int)vers);
}
else E("%08x:%08x call packet arrived, but there's "
"no RPC transport!\n",
client->xdr->x_prog,
client->xdr->x_vers);
releaseWakeLock();
}
pthread_mutex_unlock(&client->wait_cb_lock);
D("RPC-callback thread for %08x:%08x terminating.\n",
(client->xdr->x_prog | 0x01000000),
client->xdr->x_vers);
return NULL;
}
