MediaPlayerService.cpp revision b7848f1c442bc8c71020957948d1b003a62a25b7 
1/*
2**
3** Copyright 2008, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18// Proxy for media player implementations
19
20//#define LOG_NDEBUG 0
21#define LOG_TAG "MediaPlayerService"
22#include <utils/Log.h>
23
24#include <sys/types.h>
25#include <sys/stat.h>
26#include <sys/time.h>
27#include <dirent.h>
28#include <unistd.h>
29
30#include <string.h>
31
32#include <cutils/atomic.h>
33#include <cutils/properties.h> // for property_get
34
35#include <utils/misc.h>
36
37#include <binder/IBatteryStats.h>
38#include <binder/IPCThreadState.h>
39#include <binder/IServiceManager.h>
40#include <binder/MemoryHeapBase.h>
41#include <binder/MemoryBase.h>
42#include <gui/Surface.h>
43#include <utils/Errors.h>  // for status_t
44#include <utils/String8.h>
45#include <utils/SystemClock.h>
46#include <utils/Timers.h>
47#include <utils/Vector.h>
48
49#include <media/IMediaHTTPService.h>
50#include <media/IRemoteDisplay.h>
51#include <media/IRemoteDisplayClient.h>
52#include <media/MediaPlayerInterface.h>
53#include <media/mediarecorder.h>
54#include <media/MediaMetadataRetrieverInterface.h>
55#include <media/Metadata.h>
56#include <media/AudioTrack.h>
57#include <media/MemoryLeakTrackUtil.h>
58#include <media/stagefright/MediaCodecList.h>
59#include <media/stagefright/MediaErrors.h>
60#include <media/stagefright/AudioPlayer.h>
61#include <media/stagefright/foundation/ADebug.h>
62
63#include <system/audio.h>
64
65#include <private/android_filesystem_config.h>
66
67#include "ActivityManager.h"
68#include "MediaRecorderClient.h"
69#include "MediaPlayerService.h"
70#include "MetadataRetrieverClient.h"
71#include "MediaPlayerFactory.h"
72
73#include "TestPlayerStub.h"
74#include "StagefrightPlayer.h"
75#include "nuplayer/NuPlayerDriver.h"
76
77#include <OMX.h>
78
79#include "Crypto.h"
80#include "Drm.h"
81#include "HDCP.h"
82#include "HTTPBase.h"
83#include "RemoteDisplay.h"
84
85namespace {
86using android::media::Metadata;
87using android::status_t;
88using android::OK;
89using android::BAD_VALUE;
90using android::NOT_ENOUGH_DATA;
91using android::Parcel;
92
93// Max number of entries in the filter.
94const int kMaxFilterSize = 64;  // I pulled that out of thin air.
95
96// FIXME: Move all the metadata related function in the Metadata.cpp
97
98
99// Unmarshall a filter from a Parcel.
100// Filter format in a parcel:
101//
102//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
103// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
104// |                       number of entries (n)                   |
105// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
106// |                       metadata type 1                         |
107// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
108// |                       metadata type 2                         |
109// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
110//  ....
111// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
112// |                       metadata type n                         |
113// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
114//
115// @param p Parcel that should start with a filter.
116// @param[out] filter On exit contains the list of metadata type to be
117//                    filtered.
118// @param[out] status On exit contains the status code to be returned.
119// @return true if the parcel starts with a valid filter.
120bool unmarshallFilter(const Parcel& p,
121                      Metadata::Filter *filter,
122                      status_t *status)
123{
124    int32_t val;
125    if (p.readInt32(&val) != OK)
126    {
127        ALOGE("Failed to read filter's length");
128        *status = NOT_ENOUGH_DATA;
129        return false;
130    }
131
132    if( val > kMaxFilterSize || val < 0)
133    {
134        ALOGE("Invalid filter len %d", val);
135        *status = BAD_VALUE;
136        return false;
137    }
138
139    const size_t num = val;
140
141    filter->clear();
142    filter->setCapacity(num);
143
144    size_t size = num * sizeof(Metadata::Type);
145
146
147    if (p.dataAvail() < size)
148    {
149        ALOGE("Filter too short expected %d but got %d", size, p.dataAvail());
150        *status = NOT_ENOUGH_DATA;
151        return false;
152    }
153
154    const Metadata::Type *data =
155            static_cast<const Metadata::Type*>(p.readInplace(size));
156
157    if (NULL == data)
158    {
159        ALOGE("Filter had no data");
160        *status = BAD_VALUE;
161        return false;
162    }
163
164    // TODO: The stl impl of vector would be more efficient here
165    // because it degenerates into a memcpy on pod types. Try to
166    // replace later or use stl::set.
167    for (size_t i = 0; i < num; ++i)
168    {
169        filter->add(*data);
170        ++data;
171    }
172    *status = OK;
173    return true;
174}
175
176// @param filter Of metadata type.
177// @param val To be searched.
178// @return true if a match was found.
179bool findMetadata(const Metadata::Filter& filter, const int32_t val)
180{
181    // Deal with empty and ANY right away
182    if (filter.isEmpty()) return false;
183    if (filter[0] == Metadata::kAny) return true;
184
185    return filter.indexOf(val) >= 0;
186}
187
188}  // anonymous namespace
189
190
191namespace {
192using android::Parcel;
193using android::String16;
194
195// marshalling tag indicating flattened utf16 tags
196// keep in sync with frameworks/base/media/java/android/media/AudioAttributes.java
197const int32_t kAudioAttributesMarshallTagFlattenTags = 1;
198
199// Audio attributes format in a parcel:
200//
201//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
202// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
203// |                       usage                                   |
204// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
205// |                       content_type                            |
206// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
207// |                       source                                  |
208// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
209// |                       flags                                   |
210// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
211// |                       kAudioAttributesMarshallTagFlattenTags  | // ignore tags if not found
212// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
213// |                       flattened tags in UTF16                 |
214// |                         ...                                   |
215// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
216//
217// @param p Parcel that contains audio attributes.
218// @param[out] attributes On exit points to an initialized audio_attributes_t structure
219// @param[out] status On exit contains the status code to be returned.
220void unmarshallAudioAttributes(const Parcel& parcel, audio_attributes_t *attributes)
221{
222    attributes->usage = (audio_usage_t) parcel.readInt32();
223    attributes->content_type = (audio_content_type_t) parcel.readInt32();
224    attributes->source = (audio_source_t) parcel.readInt32();
225    attributes->flags = (audio_flags_mask_t) parcel.readInt32();
226    const bool hasFlattenedTag = (parcel.readInt32() == kAudioAttributesMarshallTagFlattenTags);
227    if (hasFlattenedTag) {
228        // the tags are UTF16, convert to UTF8
229        String16 tags = parcel.readString16();
230        ssize_t realTagSize = utf16_to_utf8_length(tags.string(), tags.size());
231        if (realTagSize <= 0) {
232            strcpy(attributes->tags, "");
233        } else {
234            // copy the flattened string into the attributes as the destination for the conversion:
235            // copying array size -1, array for tags was calloc'd, no need to NULL-terminate it
236            size_t tagSize = realTagSize > AUDIO_ATTRIBUTES_TAGS_MAX_SIZE - 1 ?
237                    AUDIO_ATTRIBUTES_TAGS_MAX_SIZE - 1 : realTagSize;
238            utf16_to_utf8(tags.string(), tagSize, attributes->tags);
239        }
240    } else {
241        ALOGE("unmarshallAudioAttributes() received unflattened tags, ignoring tag values");
242        strcpy(attributes->tags, "");
243    }
244}
245} // anonymous namespace
246
247
248namespace android {
249
250static bool checkPermission(const char* permissionString) {
251#ifndef HAVE_ANDROID_OS
252    return true;
253#endif
254    if (getpid() == IPCThreadState::self()->getCallingPid()) return true;
255    bool ok = checkCallingPermission(String16(permissionString));
256    if (!ok) ALOGE("Request requires %s", permissionString);
257    return ok;
258}
259
260// TODO: Find real cause of Audio/Video delay in PV framework and remove this workaround
261/* static */ int MediaPlayerService::AudioOutput::mMinBufferCount = 4;
262/* static */ bool MediaPlayerService::AudioOutput::mIsOnEmulator = false;
263
264void MediaPlayerService::instantiate() {
265    defaultServiceManager()->addService(
266            String16("media.player"), new MediaPlayerService());
267}
268
269MediaPlayerService::MediaPlayerService()
270{
271    ALOGV("MediaPlayerService created");
272    mNextConnId = 1;
273
274    mBatteryAudio.refCount = 0;
275    for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
276        mBatteryAudio.deviceOn[i] = 0;
277        mBatteryAudio.lastTime[i] = 0;
278        mBatteryAudio.totalTime[i] = 0;
279    }
280    // speaker is on by default
281    mBatteryAudio.deviceOn[SPEAKER] = 1;
282
283    // reset battery stats
284    // if the mediaserver has crashed, battery stats could be left
285    // in bad state, reset the state upon service start.
286    const sp<IServiceManager> sm(defaultServiceManager());
287    if (sm != NULL) {
288        const String16 name("batterystats");
289        sp<IBatteryStats> batteryStats =
290                interface_cast<IBatteryStats>(sm->getService(name));
291        if (batteryStats != NULL) {
292            batteryStats->noteResetVideo();
293            batteryStats->noteResetAudio();
294        }
295    }
296
297    MediaPlayerFactory::registerBuiltinFactories();
298}
299
300MediaPlayerService::~MediaPlayerService()
301{
302    ALOGV("MediaPlayerService destroyed");
303}
304
305sp<IMediaRecorder> MediaPlayerService::createMediaRecorder()
306{
307    pid_t pid = IPCThreadState::self()->getCallingPid();
308    sp<MediaRecorderClient> recorder = new MediaRecorderClient(this, pid);
309    wp<MediaRecorderClient> w = recorder;
310    Mutex::Autolock lock(mLock);
311    mMediaRecorderClients.add(w);
312    ALOGV("Create new media recorder client from pid %d", pid);
313    return recorder;
314}
315
316void MediaPlayerService::removeMediaRecorderClient(wp<MediaRecorderClient> client)
317{
318    Mutex::Autolock lock(mLock);
319    mMediaRecorderClients.remove(client);
320    ALOGV("Delete media recorder client");
321}
322
323sp<IMediaMetadataRetriever> MediaPlayerService::createMetadataRetriever()
324{
325    pid_t pid = IPCThreadState::self()->getCallingPid();
326    sp<MetadataRetrieverClient> retriever = new MetadataRetrieverClient(pid);
327    ALOGV("Create new media retriever from pid %d", pid);
328    return retriever;
329}
330
331sp<IMediaPlayer> MediaPlayerService::create(const sp<IMediaPlayerClient>& client,
332        int audioSessionId)
333{
334    pid_t pid = IPCThreadState::self()->getCallingPid();
335    int32_t connId = android_atomic_inc(&mNextConnId);
336
337    sp<Client> c = new Client(
338            this, pid, connId, client, audioSessionId,
339            IPCThreadState::self()->getCallingUid());
340
341    ALOGV("Create new client(%d) from pid %d, uid %d, ", connId, pid,
342         IPCThreadState::self()->getCallingUid());
343
344    wp<Client> w = c;
345    {
346        Mutex::Autolock lock(mLock);
347        mClients.add(w);
348    }
349    return c;
350}
351
352sp<IMediaCodecList> MediaPlayerService::getCodecList() const {
353    return MediaCodecList::getLocalInstance();
354}
355
356sp<IOMX> MediaPlayerService::getOMX() {
357    Mutex::Autolock autoLock(mLock);
358
359    if (mOMX.get() == NULL) {
360        mOMX = new OMX;
361    }
362
363    return mOMX;
364}
365
366sp<ICrypto> MediaPlayerService::makeCrypto() {
367    return new Crypto;
368}
369
370sp<IDrm> MediaPlayerService::makeDrm() {
371    return new Drm;
372}
373
374sp<IHDCP> MediaPlayerService::makeHDCP(bool createEncryptionModule) {
375    return new HDCP(createEncryptionModule);
376}
377
378sp<IRemoteDisplay> MediaPlayerService::listenForRemoteDisplay(
379        const sp<IRemoteDisplayClient>& client, const String8& iface) {
380    if (!checkPermission("android.permission.CONTROL_WIFI_DISPLAY")) {
381        return NULL;
382    }
383
384    return new RemoteDisplay(client, iface.string());
385}
386
387status_t MediaPlayerService::AudioOutput::dump(int fd, const Vector<String16>& args) const
388{
389    const size_t SIZE = 256;
390    char buffer[SIZE];
391    String8 result;
392
393    result.append(" AudioOutput\n");
394    snprintf(buffer, 255, "  stream type(%d), left - right volume(%f, %f)\n",
395            mStreamType, mLeftVolume, mRightVolume);
396    result.append(buffer);
397    snprintf(buffer, 255, "  msec per frame(%f), latency (%d)\n",
398            mMsecsPerFrame, (mTrack != 0) ? mTrack->latency() : -1);
399    result.append(buffer);
400    snprintf(buffer, 255, "  aux effect id(%d), send level (%f)\n",
401            mAuxEffectId, mSendLevel);
402    result.append(buffer);
403
404    ::write(fd, result.string(), result.size());
405    if (mTrack != 0) {
406        mTrack->dump(fd, args);
407    }
408    return NO_ERROR;
409}
410
411status_t MediaPlayerService::Client::dump(int fd, const Vector<String16>& args) const
412{
413    const size_t SIZE = 256;
414    char buffer[SIZE];
415    String8 result;
416    result.append(" Client\n");
417    snprintf(buffer, 255, "  pid(%d), connId(%d), status(%d), looping(%s)\n",
418            mPid, mConnId, mStatus, mLoop?"true": "false");
419    result.append(buffer);
420    write(fd, result.string(), result.size());
421    if (mPlayer != NULL) {
422        mPlayer->dump(fd, args);
423    }
424    if (mAudioOutput != 0) {
425        mAudioOutput->dump(fd, args);
426    }
427    write(fd, "\n", 1);
428    return NO_ERROR;
429}
430
431status_t MediaPlayerService::dump(int fd, const Vector<String16>& args)
432{
433    const size_t SIZE = 256;
434    char buffer[SIZE];
435    String8 result;
436    if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
437        snprintf(buffer, SIZE, "Permission Denial: "
438                "can't dump MediaPlayerService from pid=%d, uid=%d\n",
439                IPCThreadState::self()->getCallingPid(),
440                IPCThreadState::self()->getCallingUid());
441        result.append(buffer);
442    } else {
443        Mutex::Autolock lock(mLock);
444        for (int i = 0, n = mClients.size(); i < n; ++i) {
445            sp<Client> c = mClients[i].promote();
446            if (c != 0) c->dump(fd, args);
447        }
448        if (mMediaRecorderClients.size() == 0) {
449                result.append(" No media recorder client\n\n");
450        } else {
451            for (int i = 0, n = mMediaRecorderClients.size(); i < n; ++i) {
452                sp<MediaRecorderClient> c = mMediaRecorderClients[i].promote();
453                if (c != 0) {
454                    snprintf(buffer, 255, " MediaRecorderClient pid(%d)\n", c->mPid);
455                    result.append(buffer);
456                    write(fd, result.string(), result.size());
457                    result = "\n";
458                    c->dump(fd, args);
459                }
460            }
461        }
462
463        result.append(" Files opened and/or mapped:\n");
464        snprintf(buffer, SIZE, "/proc/%d/maps", gettid());
465        FILE *f = fopen(buffer, "r");
466        if (f) {
467            while (!feof(f)) {
468                fgets(buffer, SIZE, f);
469                if (strstr(buffer, " /storage/") ||
470                    strstr(buffer, " /system/sounds/") ||
471                    strstr(buffer, " /data/") ||
472                    strstr(buffer, " /system/media/")) {
473                    result.append("  ");
474                    result.append(buffer);
475                }
476            }
477            fclose(f);
478        } else {
479            result.append("couldn't open ");
480            result.append(buffer);
481            result.append("\n");
482        }
483
484        snprintf(buffer, SIZE, "/proc/%d/fd", gettid());
485        DIR *d = opendir(buffer);
486        if (d) {
487            struct dirent *ent;
488            while((ent = readdir(d)) != NULL) {
489                if (strcmp(ent->d_name,".") && strcmp(ent->d_name,"..")) {
490                    snprintf(buffer, SIZE, "/proc/%d/fd/%s", gettid(), ent->d_name);
491                    struct stat s;
492                    if (lstat(buffer, &s) == 0) {
493                        if ((s.st_mode & S_IFMT) == S_IFLNK) {
494                            char linkto[256];
495                            int len = readlink(buffer, linkto, sizeof(linkto));
496                            if(len > 0) {
497                                if(len > 255) {
498                                    linkto[252] = '.';
499                                    linkto[253] = '.';
500                                    linkto[254] = '.';
501                                    linkto[255] = 0;
502                                } else {
503                                    linkto[len] = 0;
504                                }
505                                if (strstr(linkto, "/storage/") == linkto ||
506                                    strstr(linkto, "/system/sounds/") == linkto ||
507                                    strstr(linkto, "/data/") == linkto ||
508                                    strstr(linkto, "/system/media/") == linkto) {
509                                    result.append("  ");
510                                    result.append(buffer);
511                                    result.append(" -> ");
512                                    result.append(linkto);
513                                    result.append("\n");
514                                }
515                            }
516                        } else {
517                            result.append("  unexpected type for ");
518                            result.append(buffer);
519                            result.append("\n");
520                        }
521                    }
522                }
523            }
524            closedir(d);
525        } else {
526            result.append("couldn't open ");
527            result.append(buffer);
528            result.append("\n");
529        }
530
531        bool dumpMem = false;
532        for (size_t i = 0; i < args.size(); i++) {
533            if (args[i] == String16("-m")) {
534                dumpMem = true;
535            }
536        }
537        if (dumpMem) {
538            dumpMemoryAddresses(fd);
539        }
540    }
541    write(fd, result.string(), result.size());
542    return NO_ERROR;
543}
544
545void MediaPlayerService::removeClient(wp<Client> client)
546{
547    Mutex::Autolock lock(mLock);
548    mClients.remove(client);
549}
550
551MediaPlayerService::Client::Client(
552        const sp<MediaPlayerService>& service, pid_t pid,
553        int32_t connId, const sp<IMediaPlayerClient>& client,
554        int audioSessionId, uid_t uid)
555{
556    ALOGV("Client(%d) constructor", connId);
557    mPid = pid;
558    mConnId = connId;
559    mService = service;
560    mClient = client;
561    mLoop = false;
562    mStatus = NO_INIT;
563    mAudioSessionId = audioSessionId;
564    mUID = uid;
565    mRetransmitEndpointValid = false;
566    mAudioAttributes = NULL;
567
568#if CALLBACK_ANTAGONIZER
569    ALOGD("create Antagonizer");
570    mAntagonizer = new Antagonizer(notify, this);
571#endif
572}
573
574MediaPlayerService::Client::~Client()
575{
576    ALOGV("Client(%d) destructor pid = %d", mConnId, mPid);
577    mAudioOutput.clear();
578    wp<Client> client(this);
579    disconnect();
580    mService->removeClient(client);
581    if (mAudioAttributes != NULL) {
582        free(mAudioAttributes);
583    }
584}
585
586void MediaPlayerService::Client::disconnect()
587{
588    ALOGV("disconnect(%d) from pid %d", mConnId, mPid);
589    // grab local reference and clear main reference to prevent future
590    // access to object
591    sp<MediaPlayerBase> p;
592    {
593        Mutex::Autolock l(mLock);
594        p = mPlayer;
595        mClient.clear();
596    }
597
598    mPlayer.clear();
599
600    // clear the notification to prevent callbacks to dead client
601    // and reset the player. We assume the player will serialize
602    // access to itself if necessary.
603    if (p != 0) {
604        p->setNotifyCallback(0, 0);
605#if CALLBACK_ANTAGONIZER
606        ALOGD("kill Antagonizer");
607        mAntagonizer->kill();
608#endif
609        p->reset();
610    }
611
612    disconnectNativeWindow();
613
614    IPCThreadState::self()->flushCommands();
615}
616
617sp<MediaPlayerBase> MediaPlayerService::Client::createPlayer(player_type playerType)
618{
619    // determine if we have the right player type
620    sp<MediaPlayerBase> p = mPlayer;
621    if ((p != NULL) && (p->playerType() != playerType)) {
622        ALOGV("delete player");
623        p.clear();
624    }
625    if (p == NULL) {
626        p = MediaPlayerFactory::createPlayer(playerType, this, notify);
627    }
628
629    if (p != NULL) {
630        p->setUID(mUID);
631    }
632
633    return p;
634}
635
636sp<MediaPlayerBase> MediaPlayerService::Client::setDataSource_pre(
637        player_type playerType)
638{
639    ALOGV("player type = %d", playerType);
640
641    // create the right type of player
642    sp<MediaPlayerBase> p = createPlayer(playerType);
643    if (p == NULL) {
644        return p;
645    }
646
647    if (!p->hardwareOutput()) {
648        mAudioOutput = new AudioOutput(mAudioSessionId, IPCThreadState::self()->getCallingUid(),
649                mPid, mAudioAttributes);
650        static_cast<MediaPlayerInterface*>(p.get())->setAudioSink(mAudioOutput);
651    }
652
653    return p;
654}
655
656void MediaPlayerService::Client::setDataSource_post(
657        const sp<MediaPlayerBase>& p,
658        status_t status)
659{
660    ALOGV(" setDataSource");
661    mStatus = status;
662    if (mStatus != OK) {
663        ALOGE("  error: %d", mStatus);
664        return;
665    }
666
667    // Set the re-transmission endpoint if one was chosen.
668    if (mRetransmitEndpointValid) {
669        mStatus = p->setRetransmitEndpoint(&mRetransmitEndpoint);
670        if (mStatus != NO_ERROR) {
671            ALOGE("setRetransmitEndpoint error: %d", mStatus);
672        }
673    }
674
675    if (mStatus == OK) {
676        mPlayer = p;
677    }
678}
679
680status_t MediaPlayerService::Client::setDataSource(
681        const sp<IMediaHTTPService> &httpService,
682        const char *url,
683        const KeyedVector<String8, String8> *headers)
684{
685    ALOGV("setDataSource(%s)", url);
686    if (url == NULL)
687        return UNKNOWN_ERROR;
688
689    if ((strncmp(url, "http://", 7) == 0) ||
690        (strncmp(url, "https://", 8) == 0) ||
691        (strncmp(url, "rtsp://", 7) == 0)) {
692        if (!checkPermission("android.permission.INTERNET")) {
693            return PERMISSION_DENIED;
694        }
695    }
696
697    if (strncmp(url, "content://", 10) == 0) {
698        // get a filedescriptor for the content Uri and
699        // pass it to the setDataSource(fd) method
700
701        String16 url16(url);
702        int fd = android::openContentProviderFile(url16);
703        if (fd < 0)
704        {
705            ALOGE("Couldn't open fd for %s", url);
706            return UNKNOWN_ERROR;
707        }
708        setDataSource(fd, 0, 0x7fffffffffLL); // this sets mStatus
709        close(fd);
710        return mStatus;
711    } else {
712        player_type playerType = MediaPlayerFactory::getPlayerType(this, url);
713        sp<MediaPlayerBase> p = setDataSource_pre(playerType);
714        if (p == NULL) {
715            return NO_INIT;
716        }
717
718        setDataSource_post(p, p->setDataSource(httpService, url, headers));
719        return mStatus;
720    }
721}
722
723status_t MediaPlayerService::Client::setDataSource(int fd, int64_t offset, int64_t length)
724{
725    ALOGV("setDataSource fd=%d, offset=%lld, length=%lld", fd, offset, length);
726    struct stat sb;
727    int ret = fstat(fd, &sb);
728    if (ret != 0) {
729        ALOGE("fstat(%d) failed: %d, %s", fd, ret, strerror(errno));
730        return UNKNOWN_ERROR;
731    }
732
733    ALOGV("st_dev  = %llu", sb.st_dev);
734    ALOGV("st_mode = %u", sb.st_mode);
735    ALOGV("st_uid  = %lu", static_cast<unsigned long>(sb.st_uid));
736    ALOGV("st_gid  = %lu", static_cast<unsigned long>(sb.st_gid));
737    ALOGV("st_size = %llu", sb.st_size);
738
739    if (offset >= sb.st_size) {
740        ALOGE("offset error");
741        ::close(fd);
742        return UNKNOWN_ERROR;
743    }
744    if (offset + length > sb.st_size) {
745        length = sb.st_size - offset;
746        ALOGV("calculated length = %lld", length);
747    }
748
749    player_type playerType = MediaPlayerFactory::getPlayerType(this,
750                                                               fd,
751                                                               offset,
752                                                               length);
753    sp<MediaPlayerBase> p = setDataSource_pre(playerType);
754    if (p == NULL) {
755        return NO_INIT;
756    }
757
758    // now set data source
759    setDataSource_post(p, p->setDataSource(fd, offset, length));
760    return mStatus;
761}
762
763status_t MediaPlayerService::Client::setDataSource(
764        const sp<IStreamSource> &source) {
765    // create the right type of player
766    player_type playerType = MediaPlayerFactory::getPlayerType(this, source);
767    sp<MediaPlayerBase> p = setDataSource_pre(playerType);
768    if (p == NULL) {
769        return NO_INIT;
770    }
771
772    // now set data source
773    setDataSource_post(p, p->setDataSource(source));
774    return mStatus;
775}
776
777void MediaPlayerService::Client::disconnectNativeWindow() {
778    if (mConnectedWindow != NULL) {
779        status_t err = native_window_api_disconnect(mConnectedWindow.get(),
780                NATIVE_WINDOW_API_MEDIA);
781
782        if (err != OK) {
783            ALOGW("native_window_api_disconnect returned an error: %s (%d)",
784                    strerror(-err), err);
785        }
786    }
787    mConnectedWindow.clear();
788}
789
790status_t MediaPlayerService::Client::setVideoSurfaceTexture(
791        const sp<IGraphicBufferProducer>& bufferProducer)
792{
793    ALOGV("[%d] setVideoSurfaceTexture(%p)", mConnId, bufferProducer.get());
794    sp<MediaPlayerBase> p = getPlayer();
795    if (p == 0) return UNKNOWN_ERROR;
796
797    sp<IBinder> binder(IInterface::asBinder(bufferProducer));
798    if (mConnectedWindowBinder == binder) {
799        return OK;
800    }
801
802    sp<ANativeWindow> anw;
803    if (bufferProducer != NULL) {
804        anw = new Surface(bufferProducer, true /* controlledByApp */);
805        status_t err = native_window_api_connect(anw.get(),
806                NATIVE_WINDOW_API_MEDIA);
807
808        if (err != OK) {
809            ALOGE("setVideoSurfaceTexture failed: %d", err);
810            // Note that we must do the reset before disconnecting from the ANW.
811            // Otherwise queue/dequeue calls could be made on the disconnected
812            // ANW, which may result in errors.
813            reset();
814
815            disconnectNativeWindow();
816
817            return err;
818        }
819    }
820
821    // Note that we must set the player's new GraphicBufferProducer before
822    // disconnecting the old one.  Otherwise queue/dequeue calls could be made
823    // on the disconnected ANW, which may result in errors.
824    status_t err = p->setVideoSurfaceTexture(bufferProducer);
825
826    disconnectNativeWindow();
827
828    mConnectedWindow = anw;
829
830    if (err == OK) {
831        mConnectedWindowBinder = binder;
832    } else {
833        disconnectNativeWindow();
834    }
835
836    return err;
837}
838
839status_t MediaPlayerService::Client::invoke(const Parcel& request,
840                                            Parcel *reply)
841{
842    sp<MediaPlayerBase> p = getPlayer();
843    if (p == NULL) return UNKNOWN_ERROR;
844    return p->invoke(request, reply);
845}
846
847// This call doesn't need to access the native player.
848status_t MediaPlayerService::Client::setMetadataFilter(const Parcel& filter)
849{
850    status_t status;
851    media::Metadata::Filter allow, drop;
852
853    if (unmarshallFilter(filter, &allow, &status) &&
854        unmarshallFilter(filter, &drop, &status)) {
855        Mutex::Autolock lock(mLock);
856
857        mMetadataAllow = allow;
858        mMetadataDrop = drop;
859    }
860    return status;
861}
862
863status_t MediaPlayerService::Client::getMetadata(
864        bool update_only, bool /*apply_filter*/, Parcel *reply)
865{
866    sp<MediaPlayerBase> player = getPlayer();
867    if (player == 0) return UNKNOWN_ERROR;
868
869    status_t status;
870    // Placeholder for the return code, updated by the caller.
871    reply->writeInt32(-1);
872
873    media::Metadata::Filter ids;
874
875    // We don't block notifications while we fetch the data. We clear
876    // mMetadataUpdated first so we don't lose notifications happening
877    // during the rest of this call.
878    {
879        Mutex::Autolock lock(mLock);
880        if (update_only) {
881            ids = mMetadataUpdated;
882        }
883        mMetadataUpdated.clear();
884    }
885
886    media::Metadata metadata(reply);
887
888    metadata.appendHeader();
889    status = player->getMetadata(ids, reply);
890
891    if (status != OK) {
892        metadata.resetParcel();
893        ALOGE("getMetadata failed %d", status);
894        return status;
895    }
896
897    // FIXME: Implement filtering on the result. Not critical since
898    // filtering takes place on the update notifications already. This
899    // would be when all the metadata are fetch and a filter is set.
900
901    // Everything is fine, update the metadata length.
902    metadata.updateLength();
903    return OK;
904}
905
906status_t MediaPlayerService::Client::prepareAsync()
907{
908    ALOGV("[%d] prepareAsync", mConnId);
909    sp<MediaPlayerBase> p = getPlayer();
910    if (p == 0) return UNKNOWN_ERROR;
911    status_t ret = p->prepareAsync();
912#if CALLBACK_ANTAGONIZER
913    ALOGD("start Antagonizer");
914    if (ret == NO_ERROR) mAntagonizer->start();
915#endif
916    return ret;
917}
918
919status_t MediaPlayerService::Client::start()
920{
921    ALOGV("[%d] start", mConnId);
922    sp<MediaPlayerBase> p = getPlayer();
923    if (p == 0) return UNKNOWN_ERROR;
924    p->setLooping(mLoop);
925    return p->start();
926}
927
928status_t MediaPlayerService::Client::stop()
929{
930    ALOGV("[%d] stop", mConnId);
931    sp<MediaPlayerBase> p = getPlayer();
932    if (p == 0) return UNKNOWN_ERROR;
933    return p->stop();
934}
935
936status_t MediaPlayerService::Client::pause()
937{
938    ALOGV("[%d] pause", mConnId);
939    sp<MediaPlayerBase> p = getPlayer();
940    if (p == 0) return UNKNOWN_ERROR;
941    return p->pause();
942}
943
944status_t MediaPlayerService::Client::isPlaying(bool* state)
945{
946    *state = false;
947    sp<MediaPlayerBase> p = getPlayer();
948    if (p == 0) return UNKNOWN_ERROR;
949    *state = p->isPlaying();
950    ALOGV("[%d] isPlaying: %d", mConnId, *state);
951    return NO_ERROR;
952}
953
954status_t MediaPlayerService::Client::getCurrentPosition(int *msec)
955{
956    ALOGV("getCurrentPosition");
957    sp<MediaPlayerBase> p = getPlayer();
958    if (p == 0) return UNKNOWN_ERROR;
959    status_t ret = p->getCurrentPosition(msec);
960    if (ret == NO_ERROR) {
961        ALOGV("[%d] getCurrentPosition = %d", mConnId, *msec);
962    } else {
963        ALOGE("getCurrentPosition returned %d", ret);
964    }
965    return ret;
966}
967
968status_t MediaPlayerService::Client::getDuration(int *msec)
969{
970    ALOGV("getDuration");
971    sp<MediaPlayerBase> p = getPlayer();
972    if (p == 0) return UNKNOWN_ERROR;
973    status_t ret = p->getDuration(msec);
974    if (ret == NO_ERROR) {
975        ALOGV("[%d] getDuration = %d", mConnId, *msec);
976    } else {
977        ALOGE("getDuration returned %d", ret);
978    }
979    return ret;
980}
981
982status_t MediaPlayerService::Client::setNextPlayer(const sp<IMediaPlayer>& player) {
983    ALOGV("setNextPlayer");
984    Mutex::Autolock l(mLock);
985    sp<Client> c = static_cast<Client*>(player.get());
986    mNextClient = c;
987
988    if (c != NULL) {
989        if (mAudioOutput != NULL) {
990            mAudioOutput->setNextOutput(c->mAudioOutput);
991        } else if ((mPlayer != NULL) && !mPlayer->hardwareOutput()) {
992            ALOGE("no current audio output");
993        }
994
995        if ((mPlayer != NULL) && (mNextClient->getPlayer() != NULL)) {
996            mPlayer->setNextPlayer(mNextClient->getPlayer());
997        }
998    }
999
1000    return OK;
1001}
1002
1003status_t MediaPlayerService::Client::seekTo(int msec)
1004{
1005    ALOGV("[%d] seekTo(%d)", mConnId, msec);
1006    sp<MediaPlayerBase> p = getPlayer();
1007    if (p == 0) return UNKNOWN_ERROR;
1008    return p->seekTo(msec);
1009}
1010
1011status_t MediaPlayerService::Client::reset()
1012{
1013    ALOGV("[%d] reset", mConnId);
1014    mRetransmitEndpointValid = false;
1015    sp<MediaPlayerBase> p = getPlayer();
1016    if (p == 0) return UNKNOWN_ERROR;
1017    return p->reset();
1018}
1019
1020status_t MediaPlayerService::Client::setAudioStreamType(audio_stream_type_t type)
1021{
1022    ALOGV("[%d] setAudioStreamType(%d)", mConnId, type);
1023    // TODO: for hardware output, call player instead
1024    Mutex::Autolock l(mLock);
1025    if (mAudioOutput != 0) mAudioOutput->setAudioStreamType(type);
1026    return NO_ERROR;
1027}
1028
1029status_t MediaPlayerService::Client::setAudioAttributes_l(const Parcel &parcel)
1030{
1031    if (mAudioAttributes != NULL) { free(mAudioAttributes); }
1032    mAudioAttributes = (audio_attributes_t *) calloc(1, sizeof(audio_attributes_t));
1033    unmarshallAudioAttributes(parcel, mAudioAttributes);
1034
1035    ALOGV("setAudioAttributes_l() usage=%d content=%d flags=0x%x tags=%s",
1036            mAudioAttributes->usage, mAudioAttributes->content_type, mAudioAttributes->flags,
1037            mAudioAttributes->tags);
1038
1039    if (mAudioOutput != 0) {
1040        mAudioOutput->setAudioAttributes(mAudioAttributes);
1041    }
1042    return NO_ERROR;
1043}
1044
1045status_t MediaPlayerService::Client::setLooping(int loop)
1046{
1047    ALOGV("[%d] setLooping(%d)", mConnId, loop);
1048    mLoop = loop;
1049    sp<MediaPlayerBase> p = getPlayer();
1050    if (p != 0) return p->setLooping(loop);
1051    return NO_ERROR;
1052}
1053
1054status_t MediaPlayerService::Client::setVolume(float leftVolume, float rightVolume)
1055{
1056    ALOGV("[%d] setVolume(%f, %f)", mConnId, leftVolume, rightVolume);
1057
1058    // for hardware output, call player instead
1059    sp<MediaPlayerBase> p = getPlayer();
1060    {
1061      Mutex::Autolock l(mLock);
1062      if (p != 0 && p->hardwareOutput()) {
1063          MediaPlayerHWInterface* hwp =
1064                  reinterpret_cast<MediaPlayerHWInterface*>(p.get());
1065          return hwp->setVolume(leftVolume, rightVolume);
1066      } else {
1067          if (mAudioOutput != 0) mAudioOutput->setVolume(leftVolume, rightVolume);
1068          return NO_ERROR;
1069      }
1070    }
1071
1072    return NO_ERROR;
1073}
1074
1075status_t MediaPlayerService::Client::setAuxEffectSendLevel(float level)
1076{
1077    ALOGV("[%d] setAuxEffectSendLevel(%f)", mConnId, level);
1078    Mutex::Autolock l(mLock);
1079    if (mAudioOutput != 0) return mAudioOutput->setAuxEffectSendLevel(level);
1080    return NO_ERROR;
1081}
1082
1083status_t MediaPlayerService::Client::attachAuxEffect(int effectId)
1084{
1085    ALOGV("[%d] attachAuxEffect(%d)", mConnId, effectId);
1086    Mutex::Autolock l(mLock);
1087    if (mAudioOutput != 0) return mAudioOutput->attachAuxEffect(effectId);
1088    return NO_ERROR;
1089}
1090
1091status_t MediaPlayerService::Client::setParameter(int key, const Parcel &request) {
1092    ALOGV("[%d] setParameter(%d)", mConnId, key);
1093    switch (key) {
1094    case KEY_PARAMETER_AUDIO_ATTRIBUTES:
1095    {
1096        Mutex::Autolock l(mLock);
1097        return setAudioAttributes_l(request);
1098    }
1099    default:
1100        sp<MediaPlayerBase> p = getPlayer();
1101        if (p == 0) { return UNKNOWN_ERROR; }
1102        return p->setParameter(key, request);
1103    }
1104}
1105
1106status_t MediaPlayerService::Client::getParameter(int key, Parcel *reply) {
1107    ALOGV("[%d] getParameter(%d)", mConnId, key);
1108    sp<MediaPlayerBase> p = getPlayer();
1109    if (p == 0) return UNKNOWN_ERROR;
1110    return p->getParameter(key, reply);
1111}
1112
1113status_t MediaPlayerService::Client::setRetransmitEndpoint(
1114        const struct sockaddr_in* endpoint) {
1115
1116    if (NULL != endpoint) {
1117        uint32_t a = ntohl(endpoint->sin_addr.s_addr);
1118        uint16_t p = ntohs(endpoint->sin_port);
1119        ALOGV("[%d] setRetransmitEndpoint(%u.%u.%u.%u:%hu)", mConnId,
1120                (a >> 24), (a >> 16) & 0xFF, (a >> 8) & 0xFF, (a & 0xFF), p);
1121    } else {
1122        ALOGV("[%d] setRetransmitEndpoint = <none>", mConnId);
1123    }
1124
1125    sp<MediaPlayerBase> p = getPlayer();
1126
1127    // Right now, the only valid time to set a retransmit endpoint is before
1128    // player selection has been made (since the presence or absence of a
1129    // retransmit endpoint is going to determine which player is selected during
1130    // setDataSource).
1131    if (p != 0) return INVALID_OPERATION;
1132
1133    if (NULL != endpoint) {
1134        mRetransmitEndpoint = *endpoint;
1135        mRetransmitEndpointValid = true;
1136    } else {
1137        mRetransmitEndpointValid = false;
1138    }
1139
1140    return NO_ERROR;
1141}
1142
1143status_t MediaPlayerService::Client::getRetransmitEndpoint(
1144        struct sockaddr_in* endpoint)
1145{
1146    if (NULL == endpoint)
1147        return BAD_VALUE;
1148
1149    sp<MediaPlayerBase> p = getPlayer();
1150
1151    if (p != NULL)
1152        return p->getRetransmitEndpoint(endpoint);
1153
1154    if (!mRetransmitEndpointValid)
1155        return NO_INIT;
1156
1157    *endpoint = mRetransmitEndpoint;
1158
1159    return NO_ERROR;
1160}
1161
1162void MediaPlayerService::Client::notify(
1163        void* cookie, int msg, int ext1, int ext2, const Parcel *obj)
1164{
1165    Client* client = static_cast<Client*>(cookie);
1166    if (client == NULL) {
1167        return;
1168    }
1169
1170    sp<IMediaPlayerClient> c;
1171    {
1172        Mutex::Autolock l(client->mLock);
1173        c = client->mClient;
1174        if (msg == MEDIA_PLAYBACK_COMPLETE && client->mNextClient != NULL) {
1175            if (client->mAudioOutput != NULL)
1176                client->mAudioOutput->switchToNextOutput();
1177            client->mNextClient->start();
1178            client->mNextClient->mClient->notify(MEDIA_INFO, MEDIA_INFO_STARTED_AS_NEXT, 0, obj);
1179        }
1180    }
1181
1182    if (MEDIA_INFO == msg &&
1183        MEDIA_INFO_METADATA_UPDATE == ext1) {
1184        const media::Metadata::Type metadata_type = ext2;
1185
1186        if(client->shouldDropMetadata(metadata_type)) {
1187            return;
1188        }
1189
1190        // Update the list of metadata that have changed. getMetadata
1191        // also access mMetadataUpdated and clears it.
1192        client->addNewMetadataUpdate(metadata_type);
1193    }
1194
1195    if (c != NULL) {
1196        ALOGV("[%d] notify (%p, %d, %d, %d)", client->mConnId, cookie, msg, ext1, ext2);
1197        c->notify(msg, ext1, ext2, obj);
1198    }
1199}
1200
1201
1202bool MediaPlayerService::Client::shouldDropMetadata(media::Metadata::Type code) const
1203{
1204    Mutex::Autolock lock(mLock);
1205
1206    if (findMetadata(mMetadataDrop, code)) {
1207        return true;
1208    }
1209
1210    if (mMetadataAllow.isEmpty() || findMetadata(mMetadataAllow, code)) {
1211        return false;
1212    } else {
1213        return true;
1214    }
1215}
1216
1217
1218void MediaPlayerService::Client::addNewMetadataUpdate(media::Metadata::Type metadata_type) {
1219    Mutex::Autolock lock(mLock);
1220    if (mMetadataUpdated.indexOf(metadata_type) < 0) {
1221        mMetadataUpdated.add(metadata_type);
1222    }
1223}
1224
1225#if CALLBACK_ANTAGONIZER
1226const int Antagonizer::interval = 10000; // 10 msecs
1227
1228Antagonizer::Antagonizer(notify_callback_f cb, void* client) :
1229    mExit(false), mActive(false), mClient(client), mCb(cb)
1230{
1231    createThread(callbackThread, this);
1232}
1233
1234void Antagonizer::kill()
1235{
1236    Mutex::Autolock _l(mLock);
1237    mActive = false;
1238    mExit = true;
1239    mCondition.wait(mLock);
1240}
1241
1242int Antagonizer::callbackThread(void* user)
1243{
1244    ALOGD("Antagonizer started");
1245    Antagonizer* p = reinterpret_cast<Antagonizer*>(user);
1246    while (!p->mExit) {
1247        if (p->mActive) {
1248            ALOGV("send event");
1249            p->mCb(p->mClient, 0, 0, 0);
1250        }
1251        usleep(interval);
1252    }
1253    Mutex::Autolock _l(p->mLock);
1254    p->mCondition.signal();
1255    ALOGD("Antagonizer stopped");
1256    return 0;
1257}
1258#endif
1259
1260#undef LOG_TAG
1261#define LOG_TAG "AudioSink"
1262MediaPlayerService::AudioOutput::AudioOutput(int sessionId, int uid, int pid,
1263        const audio_attributes_t* attr)
1264    : mCallback(NULL),
1265      mCallbackCookie(NULL),
1266      mCallbackData(NULL),
1267      mBytesWritten(0),
1268      mSessionId(sessionId),
1269      mUid(uid),
1270      mPid(pid),
1271      mFlags(AUDIO_OUTPUT_FLAG_NONE) {
1272    ALOGV("AudioOutput(%d)", sessionId);
1273    mStreamType = AUDIO_STREAM_MUSIC;
1274    mLeftVolume = 1.0;
1275    mRightVolume = 1.0;
1276    mPlaybackRatePermille = 1000;
1277    mSampleRateHz = 0;
1278    mMsecsPerFrame = 0;
1279    mAuxEffectId = 0;
1280    mSendLevel = 0.0;
1281    setMinBufferCount();
1282    mAttributes = attr;
1283}
1284
1285MediaPlayerService::AudioOutput::~AudioOutput()
1286{
1287    close();
1288    delete mCallbackData;
1289}
1290
1291void MediaPlayerService::AudioOutput::setMinBufferCount()
1292{
1293    char value[PROPERTY_VALUE_MAX];
1294    if (property_get("ro.kernel.qemu", value, 0)) {
1295        mIsOnEmulator = true;
1296        mMinBufferCount = 12;  // to prevent systematic buffer underrun for emulator
1297    }
1298}
1299
1300bool MediaPlayerService::AudioOutput::isOnEmulator()
1301{
1302    setMinBufferCount();
1303    return mIsOnEmulator;
1304}
1305
1306int MediaPlayerService::AudioOutput::getMinBufferCount()
1307{
1308    setMinBufferCount();
1309    return mMinBufferCount;
1310}
1311
1312ssize_t MediaPlayerService::AudioOutput::bufferSize() const
1313{
1314    if (mTrack == 0) return NO_INIT;
1315    return mTrack->frameCount() * frameSize();
1316}
1317
1318ssize_t MediaPlayerService::AudioOutput::frameCount() const
1319{
1320    if (mTrack == 0) return NO_INIT;
1321    return mTrack->frameCount();
1322}
1323
1324ssize_t MediaPlayerService::AudioOutput::channelCount() const
1325{
1326    if (mTrack == 0) return NO_INIT;
1327    return mTrack->channelCount();
1328}
1329
1330ssize_t MediaPlayerService::AudioOutput::frameSize() const
1331{
1332    if (mTrack == 0) return NO_INIT;
1333    return mTrack->frameSize();
1334}
1335
1336uint32_t MediaPlayerService::AudioOutput::latency () const
1337{
1338    if (mTrack == 0) return 0;
1339    return mTrack->latency();
1340}
1341
1342float MediaPlayerService::AudioOutput::msecsPerFrame() const
1343{
1344    return mMsecsPerFrame;
1345}
1346
1347status_t MediaPlayerService::AudioOutput::getPosition(uint32_t *position) const
1348{
1349    if (mTrack == 0) return NO_INIT;
1350    return mTrack->getPosition(position);
1351}
1352
1353status_t MediaPlayerService::AudioOutput::getTimestamp(AudioTimestamp &ts) const
1354{
1355    if (mTrack == 0) return NO_INIT;
1356    return mTrack->getTimestamp(ts);
1357}
1358
1359status_t MediaPlayerService::AudioOutput::getFramesWritten(uint32_t *frameswritten) const
1360{
1361    if (mTrack == 0) return NO_INIT;
1362    *frameswritten = mBytesWritten / frameSize();
1363    return OK;
1364}
1365
1366status_t MediaPlayerService::AudioOutput::setParameters(const String8& keyValuePairs)
1367{
1368    if (mTrack == 0) return NO_INIT;
1369    return mTrack->setParameters(keyValuePairs);
1370}
1371
1372String8  MediaPlayerService::AudioOutput::getParameters(const String8& keys)
1373{
1374    if (mTrack == 0) return String8::empty();
1375    return mTrack->getParameters(keys);
1376}
1377
1378void MediaPlayerService::AudioOutput::setAudioAttributes(const audio_attributes_t * attributes) {
1379    mAttributes = attributes;
1380}
1381
1382void MediaPlayerService::AudioOutput::deleteRecycledTrack()
1383{
1384    ALOGV("deleteRecycledTrack");
1385
1386    if (mRecycledTrack != 0) {
1387
1388        if (mCallbackData != NULL) {
1389            mCallbackData->setOutput(NULL);
1390            mCallbackData->endTrackSwitch();
1391        }
1392
1393        if ((mRecycledTrack->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0) {
1394            mRecycledTrack->flush();
1395        }
1396        // An offloaded track isn't flushed because the STREAM_END is reported
1397        // slightly prematurely to allow time for the gapless track switch
1398        // but this means that if we decide not to recycle the track there
1399        // could be a small amount of residual data still playing. We leave
1400        // AudioFlinger to drain the track.
1401
1402        mRecycledTrack.clear();
1403        delete mCallbackData;
1404        mCallbackData = NULL;
1405        close();
1406    }
1407}
1408
1409status_t MediaPlayerService::AudioOutput::open(
1410        uint32_t sampleRate, int channelCount, audio_channel_mask_t channelMask,
1411        audio_format_t format, int bufferCount,
1412        AudioCallback cb, void *cookie,
1413        audio_output_flags_t flags,
1414        const audio_offload_info_t *offloadInfo)
1415{
1416    mCallback = cb;
1417    mCallbackCookie = cookie;
1418
1419    // Check argument "bufferCount" against the mininum buffer count
1420    if (bufferCount < mMinBufferCount) {
1421        ALOGD("bufferCount (%d) is too small and increased to %d", bufferCount, mMinBufferCount);
1422        bufferCount = mMinBufferCount;
1423
1424    }
1425    ALOGV("open(%u, %d, 0x%x, 0x%x, %d, %d 0x%x)", sampleRate, channelCount, channelMask,
1426                format, bufferCount, mSessionId, flags);
1427    uint32_t afSampleRate;
1428    size_t afFrameCount;
1429    size_t frameCount;
1430
1431    // offloading is only supported in callback mode for now.
1432    // offloadInfo must be present if offload flag is set
1433    if (((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) &&
1434            ((cb == NULL) || (offloadInfo == NULL))) {
1435        return BAD_VALUE;
1436    }
1437
1438    if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
1439        frameCount = 0; // AudioTrack will get frame count from AudioFlinger
1440    } else {
1441        uint32_t afSampleRate;
1442        size_t afFrameCount;
1443
1444        if (AudioSystem::getOutputFrameCount(&afFrameCount, mStreamType) != NO_ERROR) {
1445            return NO_INIT;
1446        }
1447        if (AudioSystem::getOutputSamplingRate(&afSampleRate, mStreamType) != NO_ERROR) {
1448            return NO_INIT;
1449        }
1450
1451        frameCount = (sampleRate*afFrameCount*bufferCount)/afSampleRate;
1452    }
1453
1454    if (channelMask == CHANNEL_MASK_USE_CHANNEL_ORDER) {
1455        channelMask = audio_channel_out_mask_from_count(channelCount);
1456        if (0 == channelMask) {
1457            ALOGE("open() error, can\'t derive mask for %d audio channels", channelCount);
1458            return NO_INIT;
1459        }
1460    }
1461
1462    // Check whether we can recycle the track
1463    bool reuse = false;
1464    bool bothOffloaded = false;
1465
1466    if (mRecycledTrack != 0) {
1467        // check whether we are switching between two offloaded tracks
1468        bothOffloaded = (flags & mRecycledTrack->getFlags()
1469                                & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0;
1470
1471        // check if the existing track can be reused as-is, or if a new track needs to be created.
1472        reuse = true;
1473
1474        if ((mCallbackData == NULL && mCallback != NULL) ||
1475                (mCallbackData != NULL && mCallback == NULL)) {
1476            // recycled track uses callbacks but the caller wants to use writes, or vice versa
1477            ALOGV("can't chain callback and write");
1478            reuse = false;
1479        } else if ((mRecycledTrack->getSampleRate() != sampleRate) ||
1480                (mRecycledTrack->channelCount() != (uint32_t)channelCount) ) {
1481            ALOGV("samplerate, channelcount differ: %u/%u Hz, %u/%d ch",
1482                  mRecycledTrack->getSampleRate(), sampleRate,
1483                  mRecycledTrack->channelCount(), channelCount);
1484            reuse = false;
1485        } else if (flags != mFlags) {
1486            ALOGV("output flags differ %08x/%08x", flags, mFlags);
1487            reuse = false;
1488        } else if (mRecycledTrack->format() != format) {
1489            reuse = false;
1490        }
1491    } else {
1492        ALOGV("no track available to recycle");
1493    }
1494
1495    ALOGV_IF(bothOffloaded, "both tracks offloaded");
1496
1497    // If we can't recycle and both tracks are offloaded
1498    // we must close the previous output before opening a new one
1499    if (bothOffloaded && !reuse) {
1500        ALOGV("both offloaded and not recycling");
1501        deleteRecycledTrack();
1502    }
1503
1504    sp<AudioTrack> t;
1505    CallbackData *newcbd = NULL;
1506
1507    // We don't attempt to create a new track if we are recycling an
1508    // offloaded track. But, if we are recycling a non-offloaded or we
1509    // are switching where one is offloaded and one isn't then we create
1510    // the new track in advance so that we can read additional stream info
1511
1512    if (!(reuse && bothOffloaded)) {
1513        ALOGV("creating new AudioTrack");
1514
1515        if (mCallback != NULL) {
1516            newcbd = new CallbackData(this);
1517            t = new AudioTrack(
1518                    mStreamType,
1519                    sampleRate,
1520                    format,
1521                    channelMask,
1522                    frameCount,
1523                    flags,
1524                    CallbackWrapper,
1525                    newcbd,
1526                    0,  // notification frames
1527                    mSessionId,
1528                    AudioTrack::TRANSFER_CALLBACK,
1529                    offloadInfo,
1530                    mUid,
1531                    mPid,
1532                    mAttributes);
1533        } else {
1534            t = new AudioTrack(
1535                    mStreamType,
1536                    sampleRate,
1537                    format,
1538                    channelMask,
1539                    frameCount,
1540                    flags,
1541                    NULL, // callback
1542                    NULL, // user data
1543                    0, // notification frames
1544                    mSessionId,
1545                    AudioTrack::TRANSFER_DEFAULT,
1546                    NULL, // offload info
1547                    mUid,
1548                    mPid,
1549                    mAttributes);
1550        }
1551
1552        if ((t == 0) || (t->initCheck() != NO_ERROR)) {
1553            ALOGE("Unable to create audio track");
1554            delete newcbd;
1555            return NO_INIT;
1556        } else {
1557            // successful AudioTrack initialization implies a legacy stream type was generated
1558            // from the audio attributes
1559            mStreamType = t->streamType();
1560        }
1561    }
1562
1563    if (reuse) {
1564        CHECK(mRecycledTrack != NULL);
1565
1566        if (!bothOffloaded) {
1567            if (mRecycledTrack->frameCount() != t->frameCount()) {
1568                ALOGV("framecount differs: %u/%u frames",
1569                      mRecycledTrack->frameCount(), t->frameCount());
1570                reuse = false;
1571            }
1572        }
1573
1574        if (reuse) {
1575            ALOGV("chaining to next output and recycling track");
1576            close();
1577            mTrack = mRecycledTrack;
1578            mRecycledTrack.clear();
1579            if (mCallbackData != NULL) {
1580                mCallbackData->setOutput(this);
1581            }
1582            delete newcbd;
1583            return OK;
1584        }
1585    }
1586
1587    // we're not going to reuse the track, unblock and flush it
1588    // this was done earlier if both tracks are offloaded
1589    if (!bothOffloaded) {
1590        deleteRecycledTrack();
1591    }
1592
1593    CHECK((t != NULL) && ((mCallback == NULL) || (newcbd != NULL)));
1594
1595    mCallbackData = newcbd;
1596    ALOGV("setVolume");
1597    t->setVolume(mLeftVolume, mRightVolume);
1598
1599    mSampleRateHz = sampleRate;
1600    mFlags = flags;
1601    mMsecsPerFrame = mPlaybackRatePermille / (float) sampleRate;
1602    uint32_t pos;
1603    if (t->getPosition(&pos) == OK) {
1604        mBytesWritten = uint64_t(pos) * t->frameSize();
1605    }
1606    mTrack = t;
1607
1608    status_t res = NO_ERROR;
1609    if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0) {
1610        res = t->setSampleRate(mPlaybackRatePermille * mSampleRateHz / 1000);
1611        if (res == NO_ERROR) {
1612            t->setAuxEffectSendLevel(mSendLevel);
1613            res = t->attachAuxEffect(mAuxEffectId);
1614        }
1615    }
1616    ALOGV("open() DONE status %d", res);
1617    return res;
1618}
1619
1620status_t MediaPlayerService::AudioOutput::start()
1621{
1622    ALOGV("start");
1623    if (mCallbackData != NULL) {
1624        mCallbackData->endTrackSwitch();
1625    }
1626    if (mTrack != 0) {
1627        mTrack->setVolume(mLeftVolume, mRightVolume);
1628        mTrack->setAuxEffectSendLevel(mSendLevel);
1629        return mTrack->start();
1630    }
1631    return NO_INIT;
1632}
1633
1634void MediaPlayerService::AudioOutput::setNextOutput(const sp<AudioOutput>& nextOutput) {
1635    mNextOutput = nextOutput;
1636}
1637
1638
1639void MediaPlayerService::AudioOutput::switchToNextOutput() {
1640    ALOGV("switchToNextOutput");
1641    if (mNextOutput != NULL) {
1642        if (mCallbackData != NULL) {
1643            mCallbackData->beginTrackSwitch();
1644        }
1645        delete mNextOutput->mCallbackData;
1646        mNextOutput->mCallbackData = mCallbackData;
1647        mCallbackData = NULL;
1648        mNextOutput->mRecycledTrack = mTrack;
1649        mTrack.clear();
1650        mNextOutput->mSampleRateHz = mSampleRateHz;
1651        mNextOutput->mMsecsPerFrame = mMsecsPerFrame;
1652        mNextOutput->mBytesWritten = mBytesWritten;
1653        mNextOutput->mFlags = mFlags;
1654    }
1655}
1656
1657ssize_t MediaPlayerService::AudioOutput::write(const void* buffer, size_t size)
1658{
1659    LOG_ALWAYS_FATAL_IF(mCallback != NULL, "Don't call write if supplying a callback.");
1660
1661    //ALOGV("write(%p, %u)", buffer, size);
1662    if (mTrack != 0) {
1663        ssize_t ret = mTrack->write(buffer, size);
1664        if (ret >= 0) {
1665            mBytesWritten += ret;
1666        }
1667        return ret;
1668    }
1669    return NO_INIT;
1670}
1671
1672void MediaPlayerService::AudioOutput::stop()
1673{
1674    ALOGV("stop");
1675    if (mTrack != 0) mTrack->stop();
1676}
1677
1678void MediaPlayerService::AudioOutput::flush()
1679{
1680    ALOGV("flush");
1681    if (mTrack != 0) mTrack->flush();
1682}
1683
1684void MediaPlayerService::AudioOutput::pause()
1685{
1686    ALOGV("pause");
1687    if (mTrack != 0) mTrack->pause();
1688}
1689
1690void MediaPlayerService::AudioOutput::close()
1691{
1692    ALOGV("close");
1693    mTrack.clear();
1694}
1695
1696void MediaPlayerService::AudioOutput::setVolume(float left, float right)
1697{
1698    ALOGV("setVolume(%f, %f)", left, right);
1699    mLeftVolume = left;
1700    mRightVolume = right;
1701    if (mTrack != 0) {
1702        mTrack->setVolume(left, right);
1703    }
1704}
1705
1706status_t MediaPlayerService::AudioOutput::setPlaybackRatePermille(int32_t ratePermille)
1707{
1708    ALOGV("setPlaybackRatePermille(%d)", ratePermille);
1709    status_t res = NO_ERROR;
1710    if (mTrack != 0) {
1711        res = mTrack->setSampleRate(ratePermille * mSampleRateHz / 1000);
1712    } else {
1713        res = NO_INIT;
1714    }
1715    mPlaybackRatePermille = ratePermille;
1716    if (mSampleRateHz != 0) {
1717        mMsecsPerFrame = mPlaybackRatePermille / (float) mSampleRateHz;
1718    }
1719    return res;
1720}
1721
1722status_t MediaPlayerService::AudioOutput::setAuxEffectSendLevel(float level)
1723{
1724    ALOGV("setAuxEffectSendLevel(%f)", level);
1725    mSendLevel = level;
1726    if (mTrack != 0) {
1727        return mTrack->setAuxEffectSendLevel(level);
1728    }
1729    return NO_ERROR;
1730}
1731
1732status_t MediaPlayerService::AudioOutput::attachAuxEffect(int effectId)
1733{
1734    ALOGV("attachAuxEffect(%d)", effectId);
1735    mAuxEffectId = effectId;
1736    if (mTrack != 0) {
1737        return mTrack->attachAuxEffect(effectId);
1738    }
1739    return NO_ERROR;
1740}
1741
1742// static
1743void MediaPlayerService::AudioOutput::CallbackWrapper(
1744        int event, void *cookie, void *info) {
1745    //ALOGV("callbackwrapper");
1746    CallbackData *data = (CallbackData*)cookie;
1747    data->lock();
1748    AudioOutput *me = data->getOutput();
1749    AudioTrack::Buffer *buffer = (AudioTrack::Buffer *)info;
1750    if (me == NULL) {
1751        // no output set, likely because the track was scheduled to be reused
1752        // by another player, but the format turned out to be incompatible.
1753        data->unlock();
1754        if (buffer != NULL) {
1755            buffer->size = 0;
1756        }
1757        return;
1758    }
1759
1760    switch(event) {
1761    case AudioTrack::EVENT_MORE_DATA: {
1762        size_t actualSize = (*me->mCallback)(
1763                me, buffer->raw, buffer->size, me->mCallbackCookie,
1764                CB_EVENT_FILL_BUFFER);
1765
1766        if ((me->mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0 &&
1767            actualSize == 0 && buffer->size > 0 && me->mNextOutput == NULL) {
1768            // We've reached EOS but the audio track is not stopped yet,
1769            // keep playing silence.
1770
1771            memset(buffer->raw, 0, buffer->size);
1772            actualSize = buffer->size;
1773        }
1774
1775        buffer->size = actualSize;
1776        } break;
1777
1778
1779    case AudioTrack::EVENT_STREAM_END:
1780        ALOGV("callbackwrapper: deliver EVENT_STREAM_END");
1781        (*me->mCallback)(me, NULL /* buffer */, 0 /* size */,
1782                me->mCallbackCookie, CB_EVENT_STREAM_END);
1783        break;
1784
1785    case AudioTrack::EVENT_NEW_IAUDIOTRACK :
1786        ALOGV("callbackwrapper: deliver EVENT_TEAR_DOWN");
1787        (*me->mCallback)(me,  NULL /* buffer */, 0 /* size */,
1788                me->mCallbackCookie, CB_EVENT_TEAR_DOWN);
1789        break;
1790
1791    default:
1792        ALOGE("received unknown event type: %d inside CallbackWrapper !", event);
1793    }
1794
1795    data->unlock();
1796}
1797
1798int MediaPlayerService::AudioOutput::getSessionId() const
1799{
1800    return mSessionId;
1801}
1802
1803uint32_t MediaPlayerService::AudioOutput::getSampleRate() const
1804{
1805    if (mTrack == 0) return 0;
1806    return mTrack->getSampleRate();
1807}
1808
1809////////////////////////////////////////////////////////////////////////////////
1810
1811struct CallbackThread : public Thread {
1812    CallbackThread(const wp<MediaPlayerBase::AudioSink> &sink,
1813                   MediaPlayerBase::AudioSink::AudioCallback cb,
1814                   void *cookie);
1815
1816protected:
1817    virtual ~CallbackThread();
1818
1819    virtual bool threadLoop();
1820
1821private:
1822    wp<MediaPlayerBase::AudioSink> mSink;
1823    MediaPlayerBase::AudioSink::AudioCallback mCallback;
1824    void *mCookie;
1825    void *mBuffer;
1826    size_t mBufferSize;
1827
1828    CallbackThread(const CallbackThread &);
1829    CallbackThread &operator=(const CallbackThread &);
1830};
1831
1832CallbackThread::CallbackThread(
1833        const wp<MediaPlayerBase::AudioSink> &sink,
1834        MediaPlayerBase::AudioSink::AudioCallback cb,
1835        void *cookie)
1836    : mSink(sink),
1837      mCallback(cb),
1838      mCookie(cookie),
1839      mBuffer(NULL),
1840      mBufferSize(0) {
1841}
1842
1843CallbackThread::~CallbackThread() {
1844    if (mBuffer) {
1845        free(mBuffer);
1846        mBuffer = NULL;
1847    }
1848}
1849
1850bool CallbackThread::threadLoop() {
1851    sp<MediaPlayerBase::AudioSink> sink = mSink.promote();
1852    if (sink == NULL) {
1853        return false;
1854    }
1855
1856    if (mBuffer == NULL) {
1857        mBufferSize = sink->bufferSize();
1858        mBuffer = malloc(mBufferSize);
1859    }
1860
1861    size_t actualSize =
1862        (*mCallback)(sink.get(), mBuffer, mBufferSize, mCookie,
1863                MediaPlayerBase::AudioSink::CB_EVENT_FILL_BUFFER);
1864
1865    if (actualSize > 0) {
1866        sink->write(mBuffer, actualSize);
1867        // Could return false on sink->write() error or short count.
1868        // Not necessarily appropriate but would work for AudioCache behavior.
1869    }
1870
1871    return true;
1872}
1873
1874////////////////////////////////////////////////////////////////////////////////
1875
1876void MediaPlayerService::addBatteryData(uint32_t params)
1877{
1878    Mutex::Autolock lock(mLock);
1879
1880    int32_t time = systemTime() / 1000000L;
1881
1882    // change audio output devices. This notification comes from AudioFlinger
1883    if ((params & kBatteryDataSpeakerOn)
1884            || (params & kBatteryDataOtherAudioDeviceOn)) {
1885
1886        int deviceOn[NUM_AUDIO_DEVICES];
1887        for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
1888            deviceOn[i] = 0;
1889        }
1890
1891        if ((params & kBatteryDataSpeakerOn)
1892                && (params & kBatteryDataOtherAudioDeviceOn)) {
1893            deviceOn[SPEAKER_AND_OTHER] = 1;
1894        } else if (params & kBatteryDataSpeakerOn) {
1895            deviceOn[SPEAKER] = 1;
1896        } else {
1897            deviceOn[OTHER_AUDIO_DEVICE] = 1;
1898        }
1899
1900        for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
1901            if (mBatteryAudio.deviceOn[i] != deviceOn[i]){
1902
1903                if (mBatteryAudio.refCount > 0) { // if playing audio
1904                    if (!deviceOn[i]) {
1905                        mBatteryAudio.lastTime[i] += time;
1906                        mBatteryAudio.totalTime[i] += mBatteryAudio.lastTime[i];
1907                        mBatteryAudio.lastTime[i] = 0;
1908                    } else {
1909                        mBatteryAudio.lastTime[i] = 0 - time;
1910                    }
1911                }
1912
1913                mBatteryAudio.deviceOn[i] = deviceOn[i];
1914            }
1915        }
1916        return;
1917    }
1918
1919    // an audio stream is started
1920    if (params & kBatteryDataAudioFlingerStart) {
1921        // record the start time only if currently no other audio
1922        // is being played
1923        if (mBatteryAudio.refCount == 0) {
1924            for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
1925                if (mBatteryAudio.deviceOn[i]) {
1926                    mBatteryAudio.lastTime[i] -= time;
1927                }
1928            }
1929        }
1930
1931        mBatteryAudio.refCount ++;
1932        return;
1933
1934    } else if (params & kBatteryDataAudioFlingerStop) {
1935        if (mBatteryAudio.refCount <= 0) {
1936            ALOGW("Battery track warning: refCount is <= 0");
1937            return;
1938        }
1939
1940        // record the stop time only if currently this is the only
1941        // audio being played
1942        if (mBatteryAudio.refCount == 1) {
1943            for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
1944                if (mBatteryAudio.deviceOn[i]) {
1945                    mBatteryAudio.lastTime[i] += time;
1946                    mBatteryAudio.totalTime[i] += mBatteryAudio.lastTime[i];
1947                    mBatteryAudio.lastTime[i] = 0;
1948                }
1949            }
1950        }
1951
1952        mBatteryAudio.refCount --;
1953        return;
1954    }
1955
1956    int uid = IPCThreadState::self()->getCallingUid();
1957    if (uid == AID_MEDIA) {
1958        return;
1959    }
1960    int index = mBatteryData.indexOfKey(uid);
1961
1962    if (index < 0) { // create a new entry for this UID
1963        BatteryUsageInfo info;
1964        info.audioTotalTime = 0;
1965        info.videoTotalTime = 0;
1966        info.audioLastTime = 0;
1967        info.videoLastTime = 0;
1968        info.refCount = 0;
1969
1970        if (mBatteryData.add(uid, info) == NO_MEMORY) {
1971            ALOGE("Battery track error: no memory for new app");
1972            return;
1973        }
1974    }
1975
1976    BatteryUsageInfo &info = mBatteryData.editValueFor(uid);
1977
1978    if (params & kBatteryDataCodecStarted) {
1979        if (params & kBatteryDataTrackAudio) {
1980            info.audioLastTime -= time;
1981            info.refCount ++;
1982        }
1983        if (params & kBatteryDataTrackVideo) {
1984            info.videoLastTime -= time;
1985            info.refCount ++;
1986        }
1987    } else {
1988        if (info.refCount == 0) {
1989            ALOGW("Battery track warning: refCount is already 0");
1990            return;
1991        } else if (info.refCount < 0) {
1992            ALOGE("Battery track error: refCount < 0");
1993            mBatteryData.removeItem(uid);
1994            return;
1995        }
1996
1997        if (params & kBatteryDataTrackAudio) {
1998            info.audioLastTime += time;
1999            info.refCount --;
2000        }
2001        if (params & kBatteryDataTrackVideo) {
2002            info.videoLastTime += time;
2003            info.refCount --;
2004        }
2005
2006        // no stream is being played by this UID
2007        if (info.refCount == 0) {
2008            info.audioTotalTime += info.audioLastTime;
2009            info.audioLastTime = 0;
2010            info.videoTotalTime += info.videoLastTime;
2011            info.videoLastTime = 0;
2012        }
2013    }
2014}
2015
2016status_t MediaPlayerService::pullBatteryData(Parcel* reply) {
2017    Mutex::Autolock lock(mLock);
2018
2019    // audio output devices usage
2020    int32_t time = systemTime() / 1000000L; //in ms
2021    int32_t totalTime;
2022
2023    for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2024        totalTime = mBatteryAudio.totalTime[i];
2025
2026        if (mBatteryAudio.deviceOn[i]
2027            && (mBatteryAudio.lastTime[i] != 0)) {
2028                int32_t tmpTime = mBatteryAudio.lastTime[i] + time;
2029                totalTime += tmpTime;
2030        }
2031
2032        reply->writeInt32(totalTime);
2033        // reset the total time
2034        mBatteryAudio.totalTime[i] = 0;
2035   }
2036
2037    // codec usage
2038    BatteryUsageInfo info;
2039    int size = mBatteryData.size();
2040
2041    reply->writeInt32(size);
2042    int i = 0;
2043
2044    while (i < size) {
2045        info = mBatteryData.valueAt(i);
2046
2047        reply->writeInt32(mBatteryData.keyAt(i)); //UID
2048        reply->writeInt32(info.audioTotalTime);
2049        reply->writeInt32(info.videoTotalTime);
2050
2051        info.audioTotalTime = 0;
2052        info.videoTotalTime = 0;
2053
2054        // remove the UID entry where no stream is being played
2055        if (info.refCount <= 0) {
2056            mBatteryData.removeItemsAt(i);
2057            size --;
2058            i --;
2059        }
2060        i++;
2061    }
2062    return NO_ERROR;
2063}
2064} // namespace android
2065