IStreamSource.cpp revision e2b1028852120bcfded33b8f06f66b780437fe92 
1/*
2 * Copyright (C) 2010 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//#define LOG_NDEBUG 0
18#define LOG_TAG "IStreamSource"
19#include <utils/Log.h>
20
21#include <media/IStreamSource.h>
22
23#include <binder/IMemory.h>
24#include <binder/Parcel.h>
25
26namespace android {
27
28enum {
29    // IStreamSource
30    SET_LISTENER = IBinder::FIRST_CALL_TRANSACTION,
31    SET_BUFFERS,
32    ON_BUFFER_AVAILABLE,
33
34    // IStreamListener
35    QUEUE_BUFFER,
36    QUEUE_COMMAND,
37};
38
39struct BpStreamSource : public BpInterface<IStreamSource> {
40    BpStreamSource(const sp<IBinder> &impl)
41        : BpInterface<IStreamSource>(impl) {
42    }
43
44    virtual void setListener(const sp<IStreamListener> &listener) {
45        Parcel data, reply;
46        data.writeInterfaceToken(IStreamSource::getInterfaceDescriptor());
47        data.writeStrongBinder(listener->asBinder());
48        remote()->transact(SET_LISTENER, data, &reply);
49    }
50
51    virtual void setBuffers(const Vector<sp<IMemory> > &buffers) {
52        Parcel data, reply;
53        data.writeInterfaceToken(IStreamSource::getInterfaceDescriptor());
54        data.writeInt32(static_cast<int32_t>(buffers.size()));
55        for (size_t i = 0; i < buffers.size(); ++i) {
56            data.writeStrongBinder(buffers.itemAt(i)->asBinder());
57        }
58        remote()->transact(SET_BUFFERS, data, &reply);
59    }
60
61    virtual void onBufferAvailable(size_t index) {
62        Parcel data, reply;
63        data.writeInterfaceToken(IStreamSource::getInterfaceDescriptor());
64        data.writeInt32(static_cast<int32_t>(index));
65        remote()->transact(
66                ON_BUFFER_AVAILABLE, data, &reply, IBinder::FLAG_ONEWAY);
67    }
68};
69
70IMPLEMENT_META_INTERFACE(StreamSource, "android.hardware.IStreamSource");
71
72status_t BnStreamSource::onTransact(
73        uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
74    switch (code) {
75        case SET_LISTENER:
76        {
77            CHECK_INTERFACE(IStreamSource, data, reply);
78            setListener(
79                    interface_cast<IStreamListener>(data.readStrongBinder()));
80            break;
81        }
82
83        case SET_BUFFERS:
84        {
85            CHECK_INTERFACE(IStreamSource, data, reply);
86            size_t n = static_cast<size_t>(data.readInt32());
87            Vector<sp<IMemory> > buffers;
88            for (size_t i = 0; i < n; ++i) {
89                sp<IMemory> mem =
90                    interface_cast<IMemory>(data.readStrongBinder());
91
92                buffers.push(mem);
93            }
94            setBuffers(buffers);
95            break;
96        }
97
98        case ON_BUFFER_AVAILABLE:
99        {
100            CHECK_INTERFACE(IStreamSource, data, reply);
101            onBufferAvailable(static_cast<size_t>(data.readInt32()));
102            break;
103        }
104
105        default:
106            return BBinder::onTransact(code, data, reply, flags);
107    }
108
109    return OK;
110}
111
112////////////////////////////////////////////////////////////////////////////////
113
114struct BpStreamListener : public BpInterface<IStreamListener> {
115    BpStreamListener(const sp<IBinder> &impl)
116        : BpInterface<IStreamListener>(impl) {
117    }
118
119    virtual void queueBuffer(size_t index, size_t size) {
120        Parcel data, reply;
121        data.writeInterfaceToken(IStreamListener::getInterfaceDescriptor());
122        data.writeInt32(static_cast<int32_t>(index));
123        data.writeInt32(static_cast<int32_t>(size));
124
125        remote()->transact(QUEUE_BUFFER, data, &reply, IBinder::FLAG_ONEWAY);
126    }
127
128    virtual void queueCommand(Command cmd) {
129        Parcel data, reply;
130        data.writeInterfaceToken(IStreamListener::getInterfaceDescriptor());
131        data.writeInt32(static_cast<int32_t>(cmd));
132
133        remote()->transact(QUEUE_COMMAND, data, &reply, IBinder::FLAG_ONEWAY);
134    }
135};
136
137IMPLEMENT_META_INTERFACE(StreamListener, "android.hardware.IStreamListener");
138
139status_t BnStreamListener::onTransact(
140        uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
141    switch (code) {
142        case QUEUE_BUFFER:
143        {
144            CHECK_INTERFACE(IStreamListener, data, reply);
145            size_t index = static_cast<size_t>(data.readInt32());
146            size_t size = static_cast<size_t>(data.readInt32());
147
148            queueBuffer(index, size);
149            break;
150        }
151
152        case QUEUE_COMMAND:
153        {
154            CHECK_INTERFACE(IStreamListener, data, reply);
155            Command cmd = static_cast<Command>(data.readInt32());
156
157            queueCommand(cmd);
158            break;
159        }
160
161        default:
162            return BBinder::onTransact(code, data, reply, flags);
163    }
164
165    return OK;
166}
167
168}  // namespace android
169