services/core/java/com/android/server/MidiService.java - platform/frameworks/base - Gitiles

 /*
  * Copyright (C) 2014 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 an
  * limitations under the License.
  */

 package com.android.server;

 import android.content.Context;
 import android.midi.IMidiDeviceServer;
 import android.midi.IMidiListener;
 import android.midi.IMidiManager;
 import android.midi.MidiDeviceInfo;
 import android.os.Binder;
 import android.os.Bundle;
 import android.os.IBinder;
 import android.os.ParcelFileDescriptor;
 import android.os.Process;
 import android.os.RemoteException;
 import android.util.Log;

 import com.android.internal.util.IndentingPrintWriter;

 import java.io.FileDescriptor;
 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.HashMap;

 public class MidiService extends IMidiManager.Stub {
     private static final String TAG = "MidiService";

     private final Context mContext;

     // list of all our clients, keyed by Binder token
     private final HashMap<IBinder, Client> mClients = new HashMap<IBinder, Client>();

     // list of all devices, keyed by MidiDeviceInfo
     private final HashMap<MidiDeviceInfo, Device> mDevicesByInfo
             = new HashMap<MidiDeviceInfo, Device>();

     // list of all devices, keyed by IMidiDeviceServer
     private final HashMap<IBinder, Device> mDevicesByServer = new HashMap<IBinder, Device>();

     // used for assigning IDs to MIDI devices
     private int mNextDeviceId = 1;

     private final class Client implements IBinder.DeathRecipient {
         // Binder token for this client
         private final IBinder mToken;
         // This client's UID
         private final int mUid;
         // This client's PID
         private final int mPid;
         // List of all receivers for this client
         private final ArrayList<IMidiListener> mListeners = new ArrayList<IMidiListener>();

         public Client(IBinder token) {
             mToken = token;
             mUid = Binder.getCallingUid();
             mPid = Binder.getCallingPid();
         }

         public int getUid() {
             return mUid;
         }

         public void addListener(IMidiListener listener) {
             mListeners.add(listener);
         }

         public void removeListener(IMidiListener listener) {
             mListeners.remove(listener);
             if (mListeners.size() == 0) {
                 removeClient(mToken);
             }
         }

         public void deviceAdded(Device device) {
             // ignore private devices that our client cannot access
             if (!device.isUidAllowed(mUid)) return;

             MidiDeviceInfo deviceInfo = device.getDeviceInfo();
             try {
                 for (IMidiListener listener : mListeners) {
                     listener.onDeviceAdded(deviceInfo);
                 }
             } catch (RemoteException e) {
                 Log.e(TAG, "remote exception", e);
             }
         }

         public void deviceRemoved(Device device) {
             // ignore private devices that our client cannot access
             if (!device.isUidAllowed(mUid)) return;

             MidiDeviceInfo deviceInfo = device.getDeviceInfo();
             try {
                 for (IMidiListener listener : mListeners) {
                     listener.onDeviceRemoved(deviceInfo);
                 }
             } catch (RemoteException e) {
                 Log.e(TAG, "remote exception", e);
             }
         }

         public void binderDied() {
             removeClient(mToken);
         }

         @Override
         public String toString() {
             StringBuilder sb = new StringBuilder("Client: UID: ");
             sb.append(mUid);
             sb.append(" PID: ");
             sb.append(mPid);
             sb.append(" listener count: ");
             sb.append(mListeners.size());
             return sb.toString();
         }
     }

     private Client getClient(IBinder token) {
         synchronized (mClients) {
             Client client = mClients.get(token);
             if (client == null) {
                 client = new Client(token);

                 try {
                     token.linkToDeath(client, 0);
                 } catch (RemoteException e) {
                     return null;
                 }
                 mClients.put(token, client);
             }
             return client;
         }
     }

     private void removeClient(IBinder token) {
         mClients.remove(token);
     }

     private final class Device implements IBinder.DeathRecipient {
         private final IMidiDeviceServer mServer;
         private final MidiDeviceInfo mDeviceInfo;
         // UID of device creator
         private final int mUid;
         // PID of device creator
         private final int mPid;

         public Device(IMidiDeviceServer server, MidiDeviceInfo deviceInfo) {
             mServer = server;
             mDeviceInfo = deviceInfo;
             mUid = Binder.getCallingUid();
             mPid = Binder.getCallingPid();
         }

         public MidiDeviceInfo getDeviceInfo() {
             return mDeviceInfo;
         }

         public IMidiDeviceServer getDeviceServer() {
             return mServer;
         }

         public boolean isUidAllowed(int uid) {
             // FIXME
             return true;
         }

         public void binderDied() {
             synchronized (mDevicesByServer) {
                 removeDeviceLocked(this);
             }
         }

         @Override
         public String toString() {
             StringBuilder sb = new StringBuilder("Device: ");
             sb.append(mDeviceInfo);
             sb.append(" UID: ");
             sb.append(mUid);
             sb.append(" PID: ");
             sb.append(mPid);
             return sb.toString();
         }
     }

     public MidiService(Context context) {
         mContext = context;
     }

     public void registerListener(IBinder token, IMidiListener listener) {
         Client client = getClient(token);
         if (client == null) return;
         client.addListener(listener);
     }

     public void unregisterListener(IBinder token, IMidiListener listener) {
         Client client = getClient(token);
         if (client == null) return;
         client.removeListener(listener);
     }

     public MidiDeviceInfo[] getDeviceList() {
         return mDevicesByInfo.keySet().toArray(new MidiDeviceInfo[0]);
     }

     public IMidiDeviceServer openDevice(IBinder token, MidiDeviceInfo deviceInfo) {
         Device device = mDevicesByInfo.get(deviceInfo);
         if (device == null) {
             Log.e(TAG, "device not found in openDevice: " + deviceInfo);
             return null;
         }

         if (!device.isUidAllowed(Binder.getCallingUid())) {
             throw new SecurityException("Attempt to open private device with wrong UID");
         }

         return device.getDeviceServer();
     }

     public MidiDeviceInfo registerDeviceServer(IMidiDeviceServer server, int numInputPorts,
             int numOutputPorts, Bundle properties, boolean isPrivate, int type) {
         if (type != MidiDeviceInfo.TYPE_VIRTUAL && Binder.getCallingUid() != Process.SYSTEM_UID) {
             throw new SecurityException("only system can create non-virtual devices");
         }

         MidiDeviceInfo deviceInfo;
         Device device;

         synchronized (mDevicesByServer) {
             int id = mNextDeviceId++;
             deviceInfo = new MidiDeviceInfo(type, id, numInputPorts, numOutputPorts, properties);
             IBinder binder = server.asBinder();
             device = new Device(server, deviceInfo);
             try {
                 binder.linkToDeath(device, 0);
             } catch (RemoteException e) {
                 return null;
             }
             mDevicesByInfo.put(deviceInfo, device);
             mDevicesByServer.put(server.asBinder(), device);
         }

         synchronized (mClients) {
             for (Client c : mClients.values()) {
                 c.deviceAdded(device);
             }
         }

         return deviceInfo;
     }

     public void unregisterDeviceServer(IMidiDeviceServer server) {
         synchronized (mDevicesByServer) {
             removeDeviceLocked(mDevicesByServer.get(server.asBinder()));
         }
     }

     // synchronize on mDevicesByServer
     private void removeDeviceLocked(Device device) {
         if (mDevicesByServer.remove(device.getDeviceServer().asBinder()) != null) {
             mDevicesByInfo.remove(device.getDeviceInfo());

             synchronized (mClients) {
                 for (Client c : mClients.values()) {
                     c.deviceRemoved(device);
                 }
             }
         }
     }

     @Override
     public void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
         mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DUMP, TAG);
         final IndentingPrintWriter pw = new IndentingPrintWriter(writer, "  ");

         pw.println("MIDI Manager State:");
         pw.increaseIndent();

         pw.println("Devices:");
         pw.increaseIndent();
         for (Device device : mDevicesByInfo.values()) {
             pw.println(device.toString());
         }
         pw.decreaseIndent();

         pw.println("Clients:");
         pw.increaseIndent();
         for (Client client : mClients.values()) {
             pw.println(client.toString());
         }
         pw.decreaseIndent();
     }
 }
	/*
	* Copyright (C) 2014 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 an
	* limitations under the License.
	*/

	package com.android.server;

	import android.content.Context;
	import android.midi.IMidiDeviceServer;
	import android.midi.IMidiListener;
	import android.midi.IMidiManager;
	import android.midi.MidiDeviceInfo;
	import android.os.Binder;
	import android.os.Bundle;
	import android.os.IBinder;
	import android.os.ParcelFileDescriptor;
	import android.os.Process;
	import android.os.RemoteException;
	import android.util.Log;

	import com.android.internal.util.IndentingPrintWriter;

	import java.io.FileDescriptor;
	import java.io.PrintWriter;
	import java.util.ArrayList;
	import java.util.HashMap;

	public class MidiService extends IMidiManager.Stub {
	private static final String TAG = "MidiService";

	private final Context mContext;

	// list of all our clients, keyed by Binder token
	private final HashMap<IBinder, Client> mClients = new HashMap<IBinder, Client>();

	// list of all devices, keyed by MidiDeviceInfo
	private final HashMap<MidiDeviceInfo, Device> mDevicesByInfo
	= new HashMap<MidiDeviceInfo, Device>();

	// list of all devices, keyed by IMidiDeviceServer
	private final HashMap<IBinder, Device> mDevicesByServer = new HashMap<IBinder, Device>();

	// used for assigning IDs to MIDI devices
	private int mNextDeviceId = 1;

	private final class Client implements IBinder.DeathRecipient {
	// Binder token for this client
	private final IBinder mToken;
	// This client's UID
	private final int mUid;
	// This client's PID
	private final int mPid;
	// List of all receivers for this client
	private final ArrayList<IMidiListener> mListeners = new ArrayList<IMidiListener>();

	public Client(IBinder token) {
	mToken = token;
	mUid = Binder.getCallingUid();
	mPid = Binder.getCallingPid();
	}

	public int getUid() {
	return mUid;
	}

	public void addListener(IMidiListener listener) {
	mListeners.add(listener);
	}

	public void removeListener(IMidiListener listener) {
	mListeners.remove(listener);
	if (mListeners.size() == 0) {
	removeClient(mToken);
	}
	}

	public void deviceAdded(Device device) {
	// ignore private devices that our client cannot access
	if (!device.isUidAllowed(mUid)) return;

	MidiDeviceInfo deviceInfo = device.getDeviceInfo();
	try {
	for (IMidiListener listener : mListeners) {
	listener.onDeviceAdded(deviceInfo);
	}
	} catch (RemoteException e) {
	Log.e(TAG, "remote exception", e);
	}
	}

	public void deviceRemoved(Device device) {
	// ignore private devices that our client cannot access
	if (!device.isUidAllowed(mUid)) return;

	MidiDeviceInfo deviceInfo = device.getDeviceInfo();
	try {
	for (IMidiListener listener : mListeners) {
	listener.onDeviceRemoved(deviceInfo);
	}
	} catch (RemoteException e) {
	Log.e(TAG, "remote exception", e);
	}
	}

	public void binderDied() {
	removeClient(mToken);
	}

	@Override
	public String toString() {
	StringBuilder sb = new StringBuilder("Client: UID: ");
	sb.append(mUid);
	sb.append(" PID: ");
	sb.append(mPid);
	sb.append(" listener count: ");
	sb.append(mListeners.size());
	return sb.toString();
	}
	}

	private Client getClient(IBinder token) {
	synchronized (mClients) {
	Client client = mClients.get(token);
	if (client == null) {
	client = new Client(token);

	try {
	token.linkToDeath(client, 0);
	} catch (RemoteException e) {
	return null;
	}
	mClients.put(token, client);
	}
	return client;
	}
	}

	private void removeClient(IBinder token) {
	mClients.remove(token);
	}

	private final class Device implements IBinder.DeathRecipient {
	private final IMidiDeviceServer mServer;
	private final MidiDeviceInfo mDeviceInfo;
	// UID of device creator
	private final int mUid;
	// PID of device creator
	private final int mPid;

	public Device(IMidiDeviceServer server, MidiDeviceInfo deviceInfo) {
	mServer = server;
	mDeviceInfo = deviceInfo;
	mUid = Binder.getCallingUid();
	mPid = Binder.getCallingPid();
	}

	public MidiDeviceInfo getDeviceInfo() {
	return mDeviceInfo;
	}

	public IMidiDeviceServer getDeviceServer() {
	return mServer;
	}

	public boolean isUidAllowed(int uid) {
	// FIXME
	return true;
	}

	public void binderDied() {
	synchronized (mDevicesByServer) {
	removeDeviceLocked(this);
	}
	}

	@Override
	public String toString() {
	StringBuilder sb = new StringBuilder("Device: ");
	sb.append(mDeviceInfo);
	sb.append(" UID: ");
	sb.append(mUid);
	sb.append(" PID: ");
	sb.append(mPid);
	return sb.toString();
	}
	}

	public MidiService(Context context) {
	mContext = context;
	}

	public void registerListener(IBinder token, IMidiListener listener) {
	Client client = getClient(token);
	if (client == null) return;
	client.addListener(listener);
	}

	public void unregisterListener(IBinder token, IMidiListener listener) {
	Client client = getClient(token);
	if (client == null) return;
	client.removeListener(listener);
	}

	public MidiDeviceInfo[] getDeviceList() {
	return mDevicesByInfo.keySet().toArray(new MidiDeviceInfo[0]);
	}

	public IMidiDeviceServer openDevice(IBinder token, MidiDeviceInfo deviceInfo) {
	Device device = mDevicesByInfo.get(deviceInfo);
	if (device == null) {
	Log.e(TAG, "device not found in openDevice: " + deviceInfo);
	return null;
	}

	if (!device.isUidAllowed(Binder.getCallingUid())) {
	throw new SecurityException("Attempt to open private device with wrong UID");
	}

	return device.getDeviceServer();
	}

	public MidiDeviceInfo registerDeviceServer(IMidiDeviceServer server, int numInputPorts,
	int numOutputPorts, Bundle properties, boolean isPrivate, int type) {
	if (type != MidiDeviceInfo.TYPE_VIRTUAL && Binder.getCallingUid() != Process.SYSTEM_UID) {
	throw new SecurityException("only system can create non-virtual devices");
	}

	MidiDeviceInfo deviceInfo;
	Device device;

	synchronized (mDevicesByServer) {
	int id = mNextDeviceId++;
	deviceInfo = new MidiDeviceInfo(type, id, numInputPorts, numOutputPorts, properties);
	IBinder binder = server.asBinder();
	device = new Device(server, deviceInfo);
	try {
	binder.linkToDeath(device, 0);
	} catch (RemoteException e) {
	return null;
	}
	mDevicesByInfo.put(deviceInfo, device);
	mDevicesByServer.put(server.asBinder(), device);
	}

	synchronized (mClients) {
	for (Client c : mClients.values()) {
	c.deviceAdded(device);
	}
	}

	return deviceInfo;
	}

	public void unregisterDeviceServer(IMidiDeviceServer server) {
	synchronized (mDevicesByServer) {
	removeDeviceLocked(mDevicesByServer.get(server.asBinder()));
	}
	}

	// synchronize on mDevicesByServer
	private void removeDeviceLocked(Device device) {
	if (mDevicesByServer.remove(device.getDeviceServer().asBinder()) != null) {
	mDevicesByInfo.remove(device.getDeviceInfo());

	synchronized (mClients) {
	for (Client c : mClients.values()) {
	c.deviceRemoved(device);
	}
	}
	}
	}

	@Override
	public void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
	mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DUMP, TAG);
	final IndentingPrintWriter pw = new IndentingPrintWriter(writer, " ");

	pw.println("MIDI Manager State:");
	pw.increaseIndent();

	pw.println("Devices:");
	pw.increaseIndent();
	for (Device device : mDevicesByInfo.values()) {
	pw.println(device.toString());
	}
	pw.decreaseIndent();

	pw.println("Clients:");
	pw.increaseIndent();
	for (Client client : mClients.values()) {
	pw.println(client.toString());
	}
	pw.decreaseIndent();
	}
	}