Android/lineage-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove LineageAudioService

Browse Source 
Change-Id: I4aea4c62154a0f7d9d6d96e68ddf2bd401458fab
This commit is contained in:
Luca Stefani
2020-04-03 16:20:12 +02:00
committed by Michael Bestas
parent 7242fc8373
commit 67c0daf545
13 changed files with 0 additions and 1110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
sdk/src/java/lineageos/app/LineageContextConstants.java
View File

@@ -70,14 +70,6 @@ public final class LineageContextConstants {
*/
public static final String LINEAGE_LIVEDISPLAY_SERVICE = "lineagelivedisplay";
/**
* Manages enhanced audio functionality
*
* @hide
*/
public static final String LINEAGE_AUDIO_SERVICE = "lineageaudio";
/**
* Use with {@link android.content.Context#getSystemService} to retrieve a
* {@link lineageos.trust.TrustInterface} to access the Trust interface.

19
sdk/src/java/lineageos/media/AudioSessionInfo.aidl
View File

@@ -1,19 +0,0 @@
/*
* Copyright (C) 2016 The CyanogenMod 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.
*/
package lineageos.media;
parcelable AudioSessionInfo;

176
sdk/src/java/lineageos/media/AudioSessionInfo.java
View File

@@ -1,176 +0,0 @@
/*
* Copyright (C) 2016 The CyanogenMod 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.
*/
package lineageos.media;
import android.os.Parcel;
import android.os.Parcelable;
import java.util.Objects;
import lineageos.os.Build;
import lineageos.os.Concierge;
import lineageos.os.Concierge.ParcelInfo;
/**
* AudioSessionInfo represents a single instance of an audio session.
* Audio sessions are created when a new AudioTrack is started, and
* removed when the track is released. Audio session identifiers
* are unique (but may be reused) and are used as a handle by which
* an application may create audio effects on the output stream.
*
* A list of global audio sessions can be obtained by calling
* listAudioSessions() via {@link LineageAudioManager}, or a component can listen
* for the {@link LineageAudioManager#ACTION_AUDIO_SESSIONS_CHANGED} broadcast.
*
* @hide
*/
public final class AudioSessionInfo implements Parcelable {
/**
* Unique session id
*/
private final int mSessionId;
/**
* Stream type - see audio_stream_type_t
*/
private final int mStream;
/**
* Output flags - see audio_output_flags_t
*/
private final int mFlags;
/**
* Channel mask - see audio_channel_mask_t
*/
private final int mChannelMask;
/**
* UID of the source application
*/
private final int mUid;
public AudioSessionInfo(int sessionId, int stream, int flags, int channelMask, int uid) {
mSessionId = sessionId;
mStream = stream;
mFlags = flags;
mChannelMask = channelMask;
mUid = uid;
}
private AudioSessionInfo(Parcel in) {
// Read parcelable version via the Concierge
ParcelInfo parcelInfo = Concierge.receiveParcel(in);
int parcelableVersion = parcelInfo.getParcelVersion();
/* -- FIG -- */
mSessionId = in.readInt();
mStream = in.readInt();
mFlags = in.readInt();
mChannelMask = in.readInt();
mUid = in.readInt();
if (parcelableVersion > Build.LINEAGE_VERSION_CODES.FIG) {
// next-gen mind-altering shit goes here
}
// Complete parcel info for the concierge
parcelInfo.complete();
}
public int getSessionId() {
return mSessionId;
}
public int getStream() {
return mStream;
}
public int getFlags() {
return mFlags;
}
public int getChannelMask() {
return mChannelMask;
}
public int getUid() {
return mUid;
}
@Override
public String toString() {
return String.format(
"audioSessionInfo[sessionId=%d, stream=%d, flags=%d, channelMask=%d, uid=%d",
mSessionId, mStream, mFlags, mChannelMask, mUid);
}
@Override
public int hashCode() {
return Objects.hash(mSessionId, mStream, mFlags, mChannelMask, mUid);
}
@Override
public boolean equals(Object obj) {
if (obj == null || !(obj instanceof AudioSessionInfo)) {
return false;
}
final AudioSessionInfo other = (AudioSessionInfo)obj;
return this == other ||
(mSessionId == other.mSessionId &&
mStream == other.mStream &&
mFlags == other.mFlags &&
mChannelMask == other.mChannelMask &&
mUid == other.mUid);
}
/** @hide */
@Override
public int describeContents() {
return 0;
}
/** @hide */
@Override
public void writeToParcel(Parcel dest, int flags) {
// Tell the concierge to prepare the parcel
ParcelInfo parcelInfo = Concierge.prepareParcel(dest);
/* -- FIG -- */
dest.writeInt(mSessionId);
dest.writeInt(mStream);
dest.writeInt(mFlags);
dest.writeInt(mChannelMask);
dest.writeInt(mUid);
parcelInfo.complete();
}
/** @hide */
public static final Creator<AudioSessionInfo> CREATOR = new Creator<AudioSessionInfo>() {
@Override
public AudioSessionInfo createFromParcel(Parcel source) {
return new AudioSessionInfo(source);
}
@Override
public AudioSessionInfo[] newArray(int size) {
return new AudioSessionInfo[size];
}
};
}

26
sdk/src/java/lineageos/media/ILineageAudioService.aidl
View File

@@ -1,26 +0,0 @@
/*
* Copyright (C) 2016 The CyanogenMod 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.
*/
package lineageos.media;
import lineageos.media.AudioSessionInfo;
/** @hide */
interface ILineageAudioService {
List<AudioSessionInfo> listAudioSessions(int streamType);
}

172
sdk/src/java/lineageos/media/LineageAudioManager.java
View File

@@ -1,172 +0,0 @@
/*
* Copyright (C) 2016 The CyanogenMod 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.
*/
package lineageos.media;
import android.content.Context;
import android.os.IBinder;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.util.Log;
import java.util.Collections;
import java.util.List;
import lineageos.app.LineageContextConstants;
/**
* Manager for extended audio system capabilities provided by
* LineageOS.
*
* Currently, this API provides an application the ability to
* query active global audio sessions, and receive broadcasts
* when new audio sessions are created and destroyed.
*
* Applications wishing to receive audio session information
* should register for the {@link ACTION_AUDIO_SESSIONS_CHANGED}
* broadcast. This broadcast requires an application to hold the
* {@link lineageos.permission.OBSERVE_AUDIO_SESSIONS}
* permission. When receiving the broadcast, {@link EXTRA_SESSION_INFO}
* will hold the {@link AudioSessionInfo} object associated
* with the session. {@link EXTRA_SESSION_ADDED} will hold
* a boolean value, true if the session is added, false if it
* is being removed.
*
* It is important for applications to be cautious about which
* audio streams effects are attached to when using this API as
* it may interfere with their normal operation. An equalizer
* application for example would only want to react to streams
* with the type of {@link android.media.AudioManager.STREAM_MUSIC}.
*
* @see android.media.AudioManager
*
* @hide
*/
public final class LineageAudioManager {
private static final String TAG = "LineageAudioManager";
/**
* Broadcast sent when audio session are added and removed.
*/
public static final String ACTION_AUDIO_SESSIONS_CHANGED =
"lineageos.intent.action.ACTION_AUDIO_SESSIONS_CHANGED";
/**
* Extra containing {@link AudioSessionInfo}
*/
public static final String EXTRA_SESSION_INFO = "session_info";
/**
* Boolean extra, true if session is being added.
*/
public static final String EXTRA_SESSION_ADDED = "added";
private Context mContext;
private static LineageAudioManager sInstance;
private static ILineageAudioService sService;
/**
* @hide to prevent subclassing from outside of the framework
*/
private LineageAudioManager(Context context) {
Context appContext = context.getApplicationContext();
if (appContext != null) {
mContext = appContext;
} else {
mContext = context;
}
sService = getService();
if (!context.getPackageManager().hasSystemFeature(
LineageContextConstants.Features.AUDIO) || !checkService()) {
Log.wtf(TAG, "Unable to get LineageAudioService. The service either" +
" crashed, was not started, or the interface has been called to early in" +
" SystemServer init");
}
}
/**
* Get or create an instance of the {@link lineageos.media.LineageAudioManager}
* @param context
* @return {@link LineageAudioManager}
*/
public synchronized static LineageAudioManager getInstance(Context context) {
if (sInstance == null) {
sInstance = new LineageAudioManager(context);
}
return sInstance;
}
/** @hide */
public static ILineageAudioService getService() {
if (sService != null) {
return sService;
}
IBinder b = ServiceManager.getService(LineageContextConstants.LINEAGE_AUDIO_SERVICE);
if (b != null) {
sService = ILineageAudioService.Stub.asInterface(b);
return sService;
}
return null;
}
/**
* @return true if service is valid
*/
private boolean checkService() {
if (sService == null) {
Log.w(TAG, "not connected to LineageAudioService");
return false;
}
return true;
}
/**
* List audio sessions for the given stream type defined in
* {@link android.media.AudioManager}, for example,
* {@link android.media.AudioManager#STREAM_MUSIC}.
*
* @param streamType from {@link android.media.AudioManager}
* @return list of {@link AudioSessionInfo}, or empty list if none found
* @see android.media.AudioManager
*/
public List<AudioSessionInfo> listAudioSessions(int streamType) {
if (checkService()) {
try {
final List<AudioSessionInfo> sessions = sService.listAudioSessions(streamType);
if (sessions != null) {
return Collections.unmodifiableList(sessions);
}
} catch (RemoteException e) {
Log.e(TAG, "Failed to list audio sessions!", e);
}
}
return Collections.emptyList();
}
/**
* List all audio sessions.
*
* @return list of {@link AudioSessionInfo}, or empty list if none found
* @see android.media.AudioManager
*/
public List<AudioSessionInfo> listAudioSessions() {
return listAudioSessions(-1);
}
}