1 /* 2 * Copyright 2015 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 package com.android.server.camera; 17 18 import android.content.BroadcastReceiver; 19 import android.content.Context; 20 import android.content.Intent; 21 import android.content.IntentFilter; 22 import android.hardware.ICameraService; 23 import android.hardware.ICameraServiceProxy; 24 import android.nfc.INfcAdapter; 25 import android.os.Binder; 26 import android.os.Handler; 27 import android.os.IBinder; 28 import android.os.Message; 29 import android.os.Process; 30 import android.os.RemoteException; 31 import android.os.SystemProperties; 32 import android.os.UserManager; 33 import android.util.ArraySet; 34 import android.util.Slog; 35 36 import com.android.server.ServiceThread; 37 import com.android.server.SystemService; 38 39 import java.util.Collection; 40 import java.util.Set; 41 42 /** 43 * CameraService is the system_server analog to the camera service running in mediaserver. 44 * 45 * @hide 46 */ 47 public class CameraService extends SystemService 48 implements Handler.Callback, IBinder.DeathRecipient { 49 private static final String TAG = "CameraService_proxy"; 50 private static final boolean DEBUG = false; 51 52 /** 53 * This must match the ICameraService.aidl definition 54 */ 55 private static final String CAMERA_SERVICE_BINDER_NAME = "media.camera"; 56 57 public static final String CAMERA_SERVICE_PROXY_BINDER_NAME = "media.camera.proxy"; 58 59 // State arguments to use with the notifyCameraState call from camera service: 60 public static final int CAMERA_STATE_OPEN = 0; 61 public static final int CAMERA_STATE_ACTIVE = 1; 62 public static final int CAMERA_STATE_IDLE = 2; 63 public static final int CAMERA_STATE_CLOSED = 3; 64 65 // Flags arguments to NFC adapter to enable/disable NFC 66 public static final int DISABLE_POLLING_FLAGS = 0x1000; 67 public static final int ENABLE_POLLING_FLAGS = 0x0000; 68 69 // Handler message codes 70 private static final int MSG_SWITCH_USER = 1; 71 72 private static final int RETRY_DELAY_TIME = 20; //ms 73 74 private final Context mContext; 75 private final ServiceThread mHandlerThread; 76 private final Handler mHandler; 77 private UserManager mUserManager; 78 79 private final Object mLock = new Object(); 80 private Set<Integer> mEnabledCameraUsers; 81 private int mLastUser; 82 83 private ICameraService mCameraServiceRaw; 84 85 private final ArraySet<String> mActiveCameraIds = new ArraySet<>(); 86 87 private static final String NFC_NOTIFICATION_PROP = "ro.camera.notify_nfc"; 88 private static final String NFC_SERVICE_BINDER_NAME = "nfc"; 89 private static final IBinder nfcInterfaceToken = new Binder(); 90 91 private final boolean mNotifyNfc; 92 private int mActiveCameraCount = 0; 93 94 private final BroadcastReceiver mIntentReceiver = new BroadcastReceiver() { 95 @Override 96 public void onReceive(Context context, Intent intent) { 97 final String action = intent.getAction(); 98 if (action == null) return; 99 100 switch (action) { 101 case Intent.ACTION_USER_ADDED: 102 case Intent.ACTION_USER_REMOVED: 103 case Intent.ACTION_USER_INFO_CHANGED: 104 case Intent.ACTION_MANAGED_PROFILE_ADDED: 105 case Intent.ACTION_MANAGED_PROFILE_REMOVED: 106 synchronized(mLock) { 107 // Return immediately if we haven't seen any users start yet 108 if (mEnabledCameraUsers == null) return; 109 switchUserLocked(mLastUser); 110 } 111 break; 112 default: 113 break; // do nothing 114 } 115 116 } 117 }; 118 119 private final ICameraServiceProxy.Stub mCameraServiceProxy = new ICameraServiceProxy.Stub() { 120 @Override 121 public void pingForUserUpdate() { 122 notifySwitchWithRetries(30); 123 } 124 125 @Override 126 public void notifyCameraState(String cameraId, int newCameraState) { 127 String state = cameraStateToString(newCameraState); 128 if (DEBUG) Slog.v(TAG, "Camera " + cameraId + " state now " + state); 129 130 updateActivityCount(cameraId, newCameraState); 131 } 132 }; 133 134 public CameraService(Context context) { 135 super(context); 136 mContext = context; 137 mHandlerThread = new ServiceThread(TAG, Process.THREAD_PRIORITY_DISPLAY, /*allowTo*/false); 138 mHandlerThread.start(); 139 mHandler = new Handler(mHandlerThread.getLooper(), this); 140 141 mNotifyNfc = SystemProperties.getInt(NFC_NOTIFICATION_PROP, 0) > 0; 142 if (DEBUG) Slog.v(TAG, "Notify NFC behavior is " + (mNotifyNfc ? "active" : "disabled")); 143 } 144 145 @Override 146 public boolean handleMessage(Message msg) { 147 switch(msg.what) { 148 case MSG_SWITCH_USER: { 149 notifySwitchWithRetries(msg.arg1); 150 } break; 151 default: { 152 Slog.e(TAG, "CameraService error, invalid message: " + msg.what); 153 } break; 154 } 155 return true; 156 } 157 158 @Override 159 public void onStart() { 160 mUserManager = UserManager.get(mContext); 161 if (mUserManager == null) { 162 // Should never see this unless someone messes up the SystemServer service boot order. 163 throw new IllegalStateException("UserManagerService must start before CameraService!"); 164 } 165 166 IntentFilter filter = new IntentFilter(); 167 filter.addAction(Intent.ACTION_USER_ADDED); 168 filter.addAction(Intent.ACTION_USER_REMOVED); 169 filter.addAction(Intent.ACTION_USER_INFO_CHANGED); 170 filter.addAction(Intent.ACTION_MANAGED_PROFILE_ADDED); 171 filter.addAction(Intent.ACTION_MANAGED_PROFILE_REMOVED); 172 mContext.registerReceiver(mIntentReceiver, filter); 173 174 publishBinderService(CAMERA_SERVICE_PROXY_BINDER_NAME, mCameraServiceProxy); 175 } 176 177 @Override 178 public void onStartUser(int userHandle) { 179 synchronized(mLock) { 180 if (mEnabledCameraUsers == null) { 181 // Initialize mediaserver, or update mediaserver if we are recovering from a crash. 182 switchUserLocked(userHandle); 183 } 184 } 185 } 186 187 @Override 188 public void onSwitchUser(int userHandle) { 189 synchronized(mLock) { 190 switchUserLocked(userHandle); 191 } 192 } 193 194 /** 195 * Handle the death of the native camera service 196 */ 197 @Override 198 public void binderDied() { 199 if (DEBUG) Slog.w(TAG, "Native camera service has died"); 200 synchronized(mLock) { 201 mCameraServiceRaw = null; 202 203 // All cameras reset to idle on camera service death 204 boolean wasEmpty = mActiveCameraIds.isEmpty(); 205 mActiveCameraIds.clear(); 206 207 if ( mNotifyNfc && !wasEmpty ) { 208 notifyNfcService(/*enablePolling*/ true); 209 } 210 } 211 } 212 213 private void switchUserLocked(int userHandle) { 214 Set<Integer> currentUserHandles = getEnabledUserHandles(userHandle); 215 mLastUser = userHandle; 216 if (mEnabledCameraUsers == null || !mEnabledCameraUsers.equals(currentUserHandles)) { 217 // Some user handles have been added or removed, update mediaserver. 218 mEnabledCameraUsers = currentUserHandles; 219 notifyMediaserverLocked(ICameraService.EVENT_USER_SWITCHED, currentUserHandles); 220 } 221 } 222 223 private Set<Integer> getEnabledUserHandles(int currentUserHandle) { 224 int[] userProfiles = mUserManager.getEnabledProfileIds(currentUserHandle); 225 Set<Integer> handles = new ArraySet<>(userProfiles.length); 226 227 for (int id : userProfiles) { 228 handles.add(id); 229 } 230 231 return handles; 232 } 233 234 private void notifySwitchWithRetries(int retries) { 235 synchronized(mLock) { 236 if (mEnabledCameraUsers == null) { 237 return; 238 } 239 if (notifyMediaserverLocked(ICameraService.EVENT_USER_SWITCHED, mEnabledCameraUsers)) { 240 retries = 0; 241 } 242 } 243 if (retries <= 0) { 244 return; 245 } 246 Slog.i(TAG, "Could not notify camera service of user switch, retrying..."); 247 mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_SWITCH_USER, retries - 1, 0, null), 248 RETRY_DELAY_TIME); 249 } 250 251 private boolean notifyMediaserverLocked(int eventType, Set<Integer> updatedUserHandles) { 252 // Forward the user switch event to the native camera service running in the mediaserver 253 // process. 254 if (mCameraServiceRaw == null) { 255 IBinder cameraServiceBinder = getBinderService(CAMERA_SERVICE_BINDER_NAME); 256 if (cameraServiceBinder == null) { 257 Slog.w(TAG, "Could not notify mediaserver, camera service not available."); 258 return false; // Camera service not active, cannot evict user clients. 259 } 260 try { 261 cameraServiceBinder.linkToDeath(this, /*flags*/ 0); 262 } catch (RemoteException e) { 263 Slog.w(TAG, "Could not link to death of native camera service"); 264 return false; 265 } 266 267 mCameraServiceRaw = ICameraService.Stub.asInterface(cameraServiceBinder); 268 } 269 270 try { 271 mCameraServiceRaw.notifySystemEvent(eventType, toArray(updatedUserHandles)); 272 } catch (RemoteException e) { 273 Slog.w(TAG, "Could not notify mediaserver, remote exception: " + e); 274 // Not much we can do if camera service is dead. 275 return false; 276 } 277 return true; 278 } 279 280 private void updateActivityCount(String cameraId, int newCameraState) { 281 synchronized(mLock) { 282 boolean wasEmpty = mActiveCameraIds.isEmpty(); 283 switch (newCameraState) { 284 case CAMERA_STATE_OPEN: 285 break; 286 case CAMERA_STATE_ACTIVE: 287 mActiveCameraIds.add(cameraId); 288 break; 289 case CAMERA_STATE_IDLE: 290 case CAMERA_STATE_CLOSED: 291 mActiveCameraIds.remove(cameraId); 292 break; 293 } 294 boolean isEmpty = mActiveCameraIds.isEmpty(); 295 if ( mNotifyNfc && (wasEmpty != isEmpty) ) { 296 notifyNfcService(isEmpty); 297 } 298 } 299 } 300 301 private void notifyNfcService(boolean enablePolling) { 302 303 IBinder nfcServiceBinder = getBinderService(NFC_SERVICE_BINDER_NAME); 304 if (nfcServiceBinder == null) { 305 Slog.w(TAG, "Could not connect to NFC service to notify it of camera state"); 306 return; 307 } 308 INfcAdapter nfcAdapterRaw = INfcAdapter.Stub.asInterface(nfcServiceBinder); 309 int flags = enablePolling ? ENABLE_POLLING_FLAGS : DISABLE_POLLING_FLAGS; 310 if (DEBUG) Slog.v(TAG, "Setting NFC reader mode to flags " + flags); 311 try { 312 nfcAdapterRaw.setReaderMode(nfcInterfaceToken, null, flags, null); 313 } catch (RemoteException e) { 314 Slog.w(TAG, "Could not notify NFC service, remote exception: " + e); 315 } 316 } 317 318 private static int[] toArray(Collection<Integer> c) { 319 int len = c.size(); 320 int[] ret = new int[len]; 321 int idx = 0; 322 for (Integer i : c) { 323 ret[idx++] = i; 324 } 325 return ret; 326 } 327 328 private static String cameraStateToString(int newCameraState) { 329 switch (newCameraState) { 330 case CAMERA_STATE_OPEN: return "CAMERA_STATE_OPEN"; 331 case CAMERA_STATE_ACTIVE: return "CAMERA_STATE_ACTIVE"; 332 case CAMERA_STATE_IDLE: return "CAMERA_STATE_IDLE"; 333 case CAMERA_STATE_CLOSED: return "CAMERA_STATE_CLOSED"; 334 default: break; 335 } 336 return "CAMERA_STATE_UNKNOWN"; 337 } 338 } 339