audio policy: session route: move SessionRoute to common

Move the SessionRoute and SessionRouteMap inner class from policy
manager to common policy pillars as initiated by the refactor.

This code was added at teh wrong place by commit aa981194.

Bug: 22376521.

Change-Id: I29aca21614e409c59aae4b7b14163552fb0bffb1
Signed-off-by: François Gaffie <francois.gaffie@intel.com>

3 files changed, 243 insertions, 0 deletions

diff --git a/services/audiopolicy/common/managerdefinitions/Android.mk b/services/audiopolicy/common/managerdefinitions/Android.mk
index 7c265aa..8728ff3 100644
--- a/services/audiopolicy/common/managerdefinitions/Android.mk
+++ b/services/audiopolicy/common/managerdefinitions/Android.mk
@@ -16,6 +16,7 @@ LOCAL_SRC_FILES:= \
     src/EffectDescriptor.cpp \
     src/ConfigParsingUtils.cpp \
     src/SoundTriggerSession.cpp \
+    src/SessionRoute.cpp \
 
 LOCAL_SHARED_LIBRARIES := \
     libcutils \
diff --git a/services/audiopolicy/common/managerdefinitions/include/SessionRoute.h b/services/audiopolicy/common/managerdefinitions/include/SessionRoute.h
new file mode 100644
index 0000000..b4feaf0
--- /dev/null
+++ b/services/audiopolicy/common/managerdefinitions/include/SessionRoute.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <system/audio.h>
+#include <utils/KeyedVector.h>
+#include <utils/RefBase.h>
+#include <utils/Errors.h>
+
+namespace android {
+
+class DeviceDescriptor;
+
+class SessionRoute : public RefBase
+{
+public:
+    // For Input (Source) routes, use STREAM_TYPE_NA ("NA" = "not applicable)for the
+    // streamType argument
+    static const audio_stream_type_t STREAM_TYPE_NA = AUDIO_STREAM_DEFAULT;
+
+    // For Output (Sink) routes, use SOURCE_TYPE_NA ("NA" = "not applicable") for the
+    // source argument
+
+    static const audio_source_t SOURCE_TYPE_NA = AUDIO_SOURCE_DEFAULT;
+
+    SessionRoute(audio_session_t session,
+                 audio_stream_type_t streamType,
+                 audio_source_t source,
+                 sp<DeviceDescriptor> deviceDescriptor,
+                 uid_t uid)
+        : mUid(uid),
+          mSession(session),
+          mDeviceDescriptor(deviceDescriptor),
+          mRefCount(0),
+          mActivityCount(0),
+          mChanged(false),
+          mStreamType(streamType),
+          mSource(source)
+    {}
+
+    void log(const char* prefix);
+
+    bool isActive() {
+        return (mDeviceDescriptor != 0) && (mChanged || (mActivityCount > 0));
+    }
+
+    uid_t                       mUid;
+    audio_session_t             mSession;
+    sp<DeviceDescriptor>        mDeviceDescriptor;
+
+    // "reference" counting
+    int                         mRefCount;      // +/- on references
+    int                         mActivityCount; // +/- on start/stop
+    bool                        mChanged;
+    // for outputs
+    const audio_stream_type_t   mStreamType;
+    // for inputs
+    const audio_source_t        mSource;
+};
+
+class SessionRouteMap: public KeyedVector<audio_session_t, sp<SessionRoute> >
+{
+public:
+    // These constants identify the SessionRoutMap as holding EITHER input routes,
+    // or output routes.  An error will occur if an attempt is made to add a SessionRoute
+    // object with mStreamType == STREAM_TYPE_NA (i.e. an input SessionRoute) to a
+    // SessionRoutMap that is marked for output (i.e. mMapType == SESSION_ROUTE_MAP_OUTPUT)
+    // and similarly  for output SessionRoutes and Input SessionRouteMaps.
+    typedef enum
+    {
+        MAPTYPE_INPUT = 0,
+        MAPTYPE_OUTPUT = 1
+    } session_route_map_type_t;
+
+    SessionRouteMap(session_route_map_type_t mapType) :
+        mMapType(mapType)
+    {}
+
+    bool hasRoute(audio_session_t session);
+
+    void removeRoute(audio_session_t session);
+
+    int incRouteActivity(audio_session_t session);
+    int decRouteActivity(audio_session_t session);
+    bool hasRouteChanged(audio_session_t session); // also clears the changed flag
+    void log(const char* caption);
+
+    // Specify an Output(Sink) route by passing SessionRoute::SOURCE_TYPE_NA in the
+    // source argument.
+    // Specify an Input(Source) rout by passing SessionRoute::AUDIO_STREAM_DEFAULT
+    // in the streamType argument.
+    void addRoute(audio_session_t session,
+                  audio_stream_type_t streamType,
+                  audio_source_t source,
+                  sp<DeviceDescriptor> deviceDescriptor,
+                  uid_t uid);
+
+private:
+    // Used to mark a SessionRoute as for either inputs (mMapType == kSessionRouteMap_Input)
+    // or outputs (mMapType == kSessionRouteMap_Output)
+    const session_route_map_type_t mMapType;
+};
+
+}; // namespace android
diff --git a/services/audiopolicy/common/managerdefinitions/src/SessionRoute.cpp b/services/audiopolicy/common/managerdefinitions/src/SessionRoute.cpp
new file mode 100644
index 0000000..7ecfa44
--- /dev/null
+++ b/services/audiopolicy/common/managerdefinitions/src/SessionRoute.cpp
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "APM::SessionRoute"
+//#define LOG_NDEBUG 0
+
+#include "SessionRoute.h"
+#include "HwModule.h"
+#include "AudioGain.h"
+#include "DeviceDescriptor.h"
+#include <utils/Log.h>
+
+namespace android {
+
+// --- SessionRoute class implementation
+void SessionRoute::log(const char* prefix)
+{
+    ALOGI("%s[SessionRoute strm:0x%X, src:%d, sess:0x%X, dev:0x%X refs:%d act:%d",
+          prefix, mStreamType, mSource, mSession,
+          mDeviceDescriptor != 0 ? mDeviceDescriptor->type() : AUDIO_DEVICE_NONE,
+          mRefCount, mActivityCount);
+}
+
+// --- SessionRouteMap class implementation
+bool SessionRouteMap::hasRoute(audio_session_t session)
+{
+    return indexOfKey(session) >= 0 && valueFor(session)->mDeviceDescriptor != 0;
+}
+
+bool SessionRouteMap::hasRouteChanged(audio_session_t session)
+{
+    if (indexOfKey(session) >= 0) {
+        if (valueFor(session)->mChanged) {
+            valueFor(session)->mChanged = false;
+            return true;
+        }
+    }
+    return false;
+}
+
+void SessionRouteMap::removeRoute(audio_session_t session)
+{
+    sp<SessionRoute> route = indexOfKey(session) >= 0 ? valueFor(session) : 0;
+    if (route != 0) {
+        ALOG_ASSERT(route->mRefCount > 0);
+        --route->mRefCount;
+        if (route->mRefCount <= 0) {
+            removeItem(session);
+        }
+    }
+}
+
+int SessionRouteMap::incRouteActivity(audio_session_t session)
+{
+    sp<SessionRoute> route = indexOfKey(session) >= 0 ? valueFor(session) : 0;
+    return route != 0 ? ++(route->mActivityCount) : -1;
+}
+
+int SessionRouteMap::decRouteActivity(audio_session_t session)
+{
+    sp<SessionRoute> route = indexOfKey(session) >= 0 ? valueFor(session) : 0;
+    if (route != 0 && route->mActivityCount > 0) {
+        return --(route->mActivityCount);
+    } else {
+        return -1;
+    }
+}
+
+void SessionRouteMap::log(const char* caption)
+{
+    ALOGI("%s ----", caption);
+    for(size_t index = 0; index < size(); index++) {
+        valueAt(index)->log("  ");
+    }
+}
+
+void SessionRouteMap::addRoute(audio_session_t session,
+                               audio_stream_type_t streamType,
+                               audio_source_t source,
+                               sp<DeviceDescriptor> descriptor,
+                               uid_t uid)
+{
+    if (mMapType == MAPTYPE_INPUT && streamType != SessionRoute::STREAM_TYPE_NA) {
+        ALOGE("Adding Output Route to InputRouteMap");
+        return;
+    } else if (mMapType == MAPTYPE_OUTPUT && source != SessionRoute::SOURCE_TYPE_NA) {
+        ALOGE("Adding Input Route to OutputRouteMap");
+        return;
+    }
+
+    sp<SessionRoute> route = indexOfKey(session) >= 0 ? valueFor(session) : 0;
+
+    if (route != 0) {
+        if (((route->mDeviceDescriptor == 0) && (descriptor != 0)) ||
+                ((route->mDeviceDescriptor != 0) &&
+                 ((descriptor == 0) || (!route->mDeviceDescriptor->equals(descriptor))))) {
+            route->mChanged = true;
+        }
+        route->mRefCount++;
+        route->mDeviceDescriptor = descriptor;
+    } else {
+        route = new SessionRoute(session, streamType, source, descriptor, uid);
+        route->mRefCount++;
+        add(session, route);
+        if (descriptor != 0) {
+            route->mChanged = true;
+        }
+    }
+}
+
+} // namespace android