src/com/android/car/radio/service/RadioAppService.java - platform/packages/apps/Car/Radio - Git at Google

 /**
  * Copyright (C) 2018 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.
  */

 package com.android.car.radio.service;

 import static com.android.car.radio.util.Remote.tryExec;

 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.hardware.radio.ProgramList;
 import android.hardware.radio.ProgramSelector;
 import android.hardware.radio.RadioManager.ProgramInfo;
 import android.hardware.radio.RadioTuner;
 import android.media.browse.MediaBrowser.MediaItem;
 import android.media.session.PlaybackState;
 import android.os.Bundle;
 import android.os.IBinder;
 import android.os.RemoteException;
 import android.os.SystemClock;
 import android.service.media.MediaBrowserService;
 import android.util.IndentingPrintWriter;

 import androidx.annotation.GuardedBy;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.lifecycle.Lifecycle;
 import androidx.lifecycle.LifecycleOwner;
 import androidx.lifecycle.LifecycleRegistry;
 import androidx.lifecycle.LiveData;

 import com.android.car.broadcastradio.support.Program;
 import com.android.car.broadcastradio.support.media.BrowseTree;
 import com.android.car.radio.SkipMode;
 import com.android.car.radio.audio.AudioStreamController;
 import com.android.car.radio.bands.ProgramType;
 import com.android.car.radio.bands.RegionConfig;
 import com.android.car.radio.media.TunerSession;
 import com.android.car.radio.platform.ImageMemoryCache;
 import com.android.car.radio.platform.RadioManagerExt;
 import com.android.car.radio.platform.RadioTunerExt;
 import com.android.car.radio.platform.RadioTunerExt.TuneCallback;
 import com.android.car.radio.storage.RadioStorage;
 import com.android.car.radio.util.Log;

 import java.io.FileDescriptor;
 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Objects;

 /**
  * A service handling hardware tuner session and audio streaming.
  */
 public class RadioAppService extends MediaBrowserService implements LifecycleOwner {
     private static final String TAG = "BcRadioApp.service";

     public static String ACTION_APP_SERVICE = "com.android.car.radio.ACTION_APP_SERVICE";
     private static final long PROGRAM_LIST_RATE_LIMITING = 1000;

     /** Returns the {@link ComponentName} that represents this {@link MediaBrowserService}. */
     public static @NonNull ComponentName getMediaSourceComp(Context context) {
         return new ComponentName(context, RadioAppService.class);
     }

     private final Object mLock = new Object();
     private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
     private final List<IRadioAppCallback> mRadioAppCallbacks = new ArrayList<>();
     private RadioAppServiceWrapper mWrapper;

     private RadioManagerExt mRadioManager;
     @Nullable private RadioTunerExt mRadioTuner;
     @Nullable private ProgramList mProgramList;

     private RadioStorage mRadioStorage;
     private ImageMemoryCache mImageCache;
     @Nullable private AudioStreamController mAudioStreamController;

     private BrowseTree mBrowseTree;
     private TunerSession mMediaSession;

     // current observables state for newly bound IRadioAppCallbacks
     @GuardedBy("mLock")
     private ProgramInfo mCurrentProgram = null;
     @GuardedBy("mLock")
     private int mCurrentPlaybackState = PlaybackState.STATE_NONE;
     @GuardedBy("mLock")
     private long mLastProgramListPush;
     @GuardedBy("mLock")
     private RegionConfig mRegionConfigCache;

     private SkipController mSkipController;

     @Override
     public void onCreate() {
         super.onCreate();

         Log.i(TAG, "Starting RadioAppService...");

         mWrapper = new RadioAppServiceWrapper(mBinder);
         mRadioManager = new RadioManagerExt(this);
         mRadioStorage = RadioStorage.getInstance(this);
         mImageCache = new ImageMemoryCache(mRadioManager, 1000);
         mRadioTuner = mRadioManager.openSession(mHardwareCallback, null);
         if (mRadioTuner == null) {
             Log.e(TAG, "Couldn't open tuner session");
             return;
         }

         mAudioStreamController = new AudioStreamController(this, mRadioTuner,
                 this::onPlaybackStateChanged);
         mBrowseTree = new BrowseTree(this, mImageCache);
         mMediaSession = new TunerSession(this, mBrowseTree, mWrapper, mImageCache);
         setSessionToken(mMediaSession.getSessionToken());
         mBrowseTree.setAmFmRegionConfig(mRadioManager.getAmFmRegionConfig());
         LiveData<List<Program>> favorites = mRadioStorage.getFavorites();
         SkipMode skipMode = mRadioStorage.getSkipMode();
         mSkipController = new SkipController(mBinder, favorites, skipMode);
         favorites.observe(this, favs -> mBrowseTree.setFavorites(new HashSet<>(favs)));

         mProgramList = mRadioTuner.getDynamicProgramList(null);
         if (mProgramList != null) {
             mBrowseTree.setProgramList(mProgramList);
             mProgramList.registerListCallback(new ProgramList.ListCallback() {
                 @Override
                 public void onItemChanged(@NonNull ProgramSelector.Identifier id) {
                     onProgramListChanged();
                 }
             });
             mProgramList.addOnCompleteListener(this::pushProgramListUpdate);
         }

         mLifecycleRegistry.markState(Lifecycle.State.CREATED);
     }

     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
         Log.d(TAG, "onStartCommand intent [%s] flags[%d] startId[%d]",
                 intent.toString(), flags, startId);
         mLifecycleRegistry.markState(Lifecycle.State.STARTED);
         if (BrowseTree.ACTION_PLAY_BROADCASTRADIO.equals(intent.getAction())) {
             Log.i(TAG, "Executing general play radio intent");
             mMediaSession.getController().getTransportControls().playFromMediaId(
                     mBrowseTree.getRoot().getRootId(), null);
             return START_NOT_STICKY;
         }

         return super.onStartCommand(intent, flags, startId);
     }

     @Override
     public IBinder onBind(Intent intent) {
         Log.i(TAG, "onBind intent[" + intent + "]");
         mLifecycleRegistry.markState(Lifecycle.State.STARTED);
         if (mRadioTuner == null) return null;
         if (ACTION_APP_SERVICE.equals(intent.getAction())) {
             return mBinder;
         }
         return super.onBind(intent);
     }

     @Override
     public boolean onUnbind(Intent intent) {
         mLifecycleRegistry.markState(Lifecycle.State.CREATED);
         return false;
     }

     @Override
     public void onDestroy() {
         Log.i(TAG, "Shutting down RadioAppService...");

         mLifecycleRegistry.markState(Lifecycle.State.DESTROYED);

         if (mMediaSession != null) mMediaSession.release();
         close();

         super.onDestroy();
     }

     @NonNull
     @Override
     public Lifecycle getLifecycle() {
         return mLifecycleRegistry;
     }

     private void onPlaybackStateChanged(int newState) {
         Log.d(TAG, "onPlaybackStateChanged new state [%d]", newState);
         synchronized (mLock) {
             mCurrentPlaybackState = newState;
             for (IRadioAppCallback callback : mRadioAppCallbacks) {
                 tryExec(() -> callback.onPlaybackStateChanged(newState));
             }
         }
     }

     private void onProgramListChanged() {
         if (mProgramList == null) return;
         synchronized (mLock) {
             if (SystemClock.elapsedRealtime() - mLastProgramListPush > PROGRAM_LIST_RATE_LIMITING) {
                 pushProgramListUpdate();
             }
         }
     }

     private void pushProgramListUpdate() {
         if (mProgramList == null) return;
         List<ProgramInfo> plist = mProgramList.toList();

         synchronized (mLock) {
             mLastProgramListPush = SystemClock.elapsedRealtime();
             for (IRadioAppCallback callback : mRadioAppCallbacks) {
                 tryExec(() -> callback.onProgramListChanged(plist));
             }
         }
     }

     private void tuneToDefault(@Nullable ProgramType pt) {
         synchronized (mLock) {
             if (mRadioTuner == null) throw new IllegalStateException("Tuner session is closed");
             TuneCallback tuneCb = mAudioStreamController.preparePlayback(
                     AudioStreamController.OPERATION_TUNE);
             if (tuneCb == null) return;

             ProgramSelector sel = mRadioStorage.getRecentlySelected(pt);
             if (sel != null) {
                 Log.i(TAG, "Restoring recently selected program: " + sel);
                 try {
                     mRadioTuner.tune(sel, tuneCb);
                 } catch (IllegalArgumentException | UnsupportedOperationException e) {
                     Log.e(TAG, "Can't restore recently selected program: " + sel, e);
                 }
                 return;
             }

             if (pt == null) pt = ProgramType.FM;
             Log.i(TAG, "No recently selected program set, selecting default channel for " + pt);
             pt.tuneToDefault(mRadioTuner, mWrapper.getRegionConfig(), tuneCb);
         }
     }

     private void close() {
         synchronized (mLock) {
             if (mAudioStreamController != null) {
                 mAudioStreamController.requestMuted(true);
                 mAudioStreamController = null;
             }
             if (mProgramList != null) {
                 ProgramList oldList = mProgramList;
                 mProgramList = null;
                 oldList.close();
             }
             if (mRadioTuner != null) {
                 mRadioTuner.close();
                 mRadioTuner = null;
             }
         }
     }

     @Override
     public BrowserRoot onGetRoot(String clientPackageName, int clientUid, Bundle rootHints) {
         /* Radio application may restrict who can read its MediaBrowser tree.
          * Our implementation doesn't.
          */
         return mBrowseTree.getRoot();
     }

     @Override
     public void onLoadChildren(final String parentMediaId, final Result<List<MediaItem>> result) {
         mBrowseTree.loadChildren(parentMediaId, result);
     }

     private void onHardwareError() {
         close();
         stopSelf();
         synchronized (mLock) {
             for (IRadioAppCallback callback : mRadioAppCallbacks) {
                 tryExec(() -> callback.onHardwareError());
             }
         }
     }

     @Override
     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
         try (IndentingPrintWriter writer = new IndentingPrintWriter(pw)) {
             pw.println("RadioAppService:");
             writer.increaseIndent();
             if (mSkipController != null) {
                 writer.increaseIndent();
                 mSkipController.dump(writer);
                 writer.decreaseIndent();
             } else {
                 pw.println("No SkipController");
             }

             if (mAudioStreamController != null) {
                 writer.increaseIndent();
                 mAudioStreamController.dump(writer);
                 writer.decreaseIndent();
             } else {
                 pw.println("No AudioStreamController");
             }
             writer.decreaseIndent();
         }
     }

     private final IRadioAppService.Stub mBinder = new IRadioAppService.Stub() {
         @Override
         public void addCallback(IRadioAppCallback callback) throws RemoteException {
             synchronized (mLock) {
                 if (mCurrentProgram != null) callback.onCurrentProgramChanged(mCurrentProgram);
                 callback.onPlaybackStateChanged(mCurrentPlaybackState);
                 if (mProgramList != null) callback.onProgramListChanged(mProgramList.toList());
                 mRadioAppCallbacks.add(callback);
             }
         }

         @Override
         public void removeCallback(IRadioAppCallback callback) {
             synchronized (mLock) {
                 mRadioAppCallbacks.remove(callback);
             }
         }

         @Override
         public void tune(ProgramSelector sel, ITuneCallback callback) {
             Objects.requireNonNull(callback);
             synchronized (mLock) {
                 if (mRadioTuner == null) throw new IllegalStateException("Tuner session is closed");
                 TuneCallback tuneCb = mAudioStreamController.preparePlayback(
                         AudioStreamController.OPERATION_TUNE);
                 if (tuneCb == null) return;
                 mRadioTuner.tune(sel, tuneCb.alsoCall(
                         succ -> tryExec(() -> callback.onFinished(succ))));
             }
         }

         @Override
         public void seek(boolean forward, ITuneCallback callback) {
             Objects.requireNonNull(callback);
             synchronized (mLock) {
                 if (mRadioTuner == null) throw new IllegalStateException("Tuner session is closed");
                 TuneCallback tuneCb = mAudioStreamController.preparePlayback(forward
                         ? AudioStreamController.OPERATION_SEEK_FWD
                         : AudioStreamController.OPERATION_SEEK_BKW);
                 if (tuneCb == null) return;
                 mRadioTuner.seek(forward, tuneCb.alsoCall(
                         succ -> tryExec(() -> callback.onFinished(succ))));
             }
         }

         @Override
         public void skip(boolean forward, ITuneCallback callback) throws RemoteException {
             Objects.requireNonNull(callback);

             mSkipController.skip(forward, callback);
         }

         @Override
         public void setSkipMode(int mode) {
             SkipMode newMode = SkipMode.valueOf(mode);
             if (newMode == null) {
                 Log.e(TAG, "setSkipMode(): invalid mode " + mode);
                 return;
             }
             mSkipController.setSkipMode(newMode);
             mRadioStorage.setSkipMode(newMode);
         }

         @Override
         public void step(boolean forward, ITuneCallback callback) {
             Objects.requireNonNull(callback);
             synchronized (mLock) {
                 if (mRadioTuner == null) throw new IllegalStateException("Tuner session is closed");
                 TuneCallback tuneCb = mAudioStreamController.preparePlayback(forward
                         ? AudioStreamController.OPERATION_STEP_FWD
                         : AudioStreamController.OPERATION_STEP_BKW);
                 if (tuneCb == null) return;
                 mRadioTuner.step(forward, tuneCb.alsoCall(
                         succ -> tryExec(() -> callback.onFinished(succ))));
             }
         }

         @Override
         public void setMuted(boolean muted) {
             if (mAudioStreamController == null) return;
             if (muted) mRadioTuner.cancel();
             mAudioStreamController.requestMuted(muted);
         }

         @Override
         public void tuneToDefaultIfNeeded() {
             synchronized (mLock) {
                 if (mRadioTuner == null) {
                     throw new IllegalStateException("Tuner session is closed");
                 }

                 if (mCurrentPlaybackState != PlaybackState.STATE_NONE) {
                     return;
                 }
             }

             tuneToDefault(null);
         }

         @Override
         public void switchBand(ProgramType band) {
             tuneToDefault(band);
         }

         @Override
         public boolean isProgramListSupported() {
             return mProgramList != null;
         }

         @Override
         public RegionConfig getRegionConfig() {
             synchronized (mLock) {
                 if (mRegionConfigCache == null) {
                     mRegionConfigCache = new RegionConfig(mRadioManager.getAmFmRegionConfig());
                 }
                 return mRegionConfigCache;
             }
         }
     };

     private RadioTuner.Callback mHardwareCallback = new RadioTuner.Callback() {
         @Override
         public void onProgramInfoChanged(ProgramInfo info) {
             Objects.requireNonNull(info);

             Log.d(TAG, "Program info changed: %s", info);

             synchronized (mLock) {
                 mCurrentProgram = info;

                 /* Storing recently selected program might be limited to explicit tune calls only
                  * (including next/prev seek), but the implementation would be nontrivial with the
                  * current API. For now, let's make it simple and make it react to all program
                  * selector changes. */
                 mRadioStorage.setRecentlySelected(info.getSelector());
                 for (IRadioAppCallback callback : mRadioAppCallbacks) {
                     tryExec(() -> callback.onCurrentProgramChanged(info));
                 }
             }
         }

         @Override
         public void onError(int status) {
             switch (status) {
                 case RadioTuner.ERROR_HARDWARE_FAILURE:
                 case RadioTuner.ERROR_SERVER_DIED:
                     Log.e(TAG, "Fatal hardware error: " + status);
                     onHardwareError();
                     break;
                 default:
                     Log.w(TAG, "Hardware error: " + status);
             }
         }

         @Override
         public void onControlChanged(boolean control) {
             if (!control) onHardwareError();
         }
     };
 }
	/**
	* Copyright (C) 2018 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.
	*/

	package com.android.car.radio.service;

	import static com.android.car.radio.util.Remote.tryExec;

	import android.content.ComponentName;
	import android.content.Context;
	import android.content.Intent;
	import android.hardware.radio.ProgramList;
	import android.hardware.radio.ProgramSelector;
	import android.hardware.radio.RadioManager.ProgramInfo;
	import android.hardware.radio.RadioTuner;
	import android.media.browse.MediaBrowser.MediaItem;
	import android.media.session.PlaybackState;
	import android.os.Bundle;
	import android.os.IBinder;
	import android.os.RemoteException;
	import android.os.SystemClock;
	import android.service.media.MediaBrowserService;
	import android.util.IndentingPrintWriter;

	import androidx.annotation.GuardedBy;
	import androidx.annotation.NonNull;
	import androidx.annotation.Nullable;
	import androidx.lifecycle.Lifecycle;
	import androidx.lifecycle.LifecycleOwner;
	import androidx.lifecycle.LifecycleRegistry;
	import androidx.lifecycle.LiveData;

	import com.android.car.broadcastradio.support.Program;
	import com.android.car.broadcastradio.support.media.BrowseTree;
	import com.android.car.radio.SkipMode;
	import com.android.car.radio.audio.AudioStreamController;
	import com.android.car.radio.bands.ProgramType;
	import com.android.car.radio.bands.RegionConfig;
	import com.android.car.radio.media.TunerSession;
	import com.android.car.radio.platform.ImageMemoryCache;
	import com.android.car.radio.platform.RadioManagerExt;
	import com.android.car.radio.platform.RadioTunerExt;
	import com.android.car.radio.platform.RadioTunerExt.TuneCallback;
	import com.android.car.radio.storage.RadioStorage;
	import com.android.car.radio.util.Log;

	import java.io.FileDescriptor;
	import java.io.PrintWriter;
	import java.util.ArrayList;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Objects;

	/**
	* A service handling hardware tuner session and audio streaming.
	*/
	public class RadioAppService extends MediaBrowserService implements LifecycleOwner {
	private static final String TAG = "BcRadioApp.service";

	public static String ACTION_APP_SERVICE = "com.android.car.radio.ACTION_APP_SERVICE";
	private static final long PROGRAM_LIST_RATE_LIMITING = 1000;

	/** Returns the {@link ComponentName} that represents this {@link MediaBrowserService}. */
	public static @NonNull ComponentName getMediaSourceComp(Context context) {
	return new ComponentName(context, RadioAppService.class);
	}

	private final Object mLock = new Object();
	private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
	private final List<IRadioAppCallback> mRadioAppCallbacks = new ArrayList<>();
	private RadioAppServiceWrapper mWrapper;

	private RadioManagerExt mRadioManager;
	@Nullable private RadioTunerExt mRadioTuner;
	@Nullable private ProgramList mProgramList;

	private RadioStorage mRadioStorage;
	private ImageMemoryCache mImageCache;
	@Nullable private AudioStreamController mAudioStreamController;

	private BrowseTree mBrowseTree;
	private TunerSession mMediaSession;

	// current observables state for newly bound IRadioAppCallbacks
	@GuardedBy("mLock")
	private ProgramInfo mCurrentProgram = null;
	@GuardedBy("mLock")
	private int mCurrentPlaybackState = PlaybackState.STATE_NONE;
	@GuardedBy("mLock")
	private long mLastProgramListPush;
	@GuardedBy("mLock")
	private RegionConfig mRegionConfigCache;

	private SkipController mSkipController;

	@Override
	public void onCreate() {
	super.onCreate();

	Log.i(TAG, "Starting RadioAppService...");

	mWrapper = new RadioAppServiceWrapper(mBinder);
	mRadioManager = new RadioManagerExt(this);
	mRadioStorage = RadioStorage.getInstance(this);
	mImageCache = new ImageMemoryCache(mRadioManager, 1000);
	mRadioTuner = mRadioManager.openSession(mHardwareCallback, null);
	if (mRadioTuner == null) {
	Log.e(TAG, "Couldn't open tuner session");
	return;
	}

	mAudioStreamController = new AudioStreamController(this, mRadioTuner,
	this::onPlaybackStateChanged);
	mBrowseTree = new BrowseTree(this, mImageCache);
	mMediaSession = new TunerSession(this, mBrowseTree, mWrapper, mImageCache);
	setSessionToken(mMediaSession.getSessionToken());
	mBrowseTree.setAmFmRegionConfig(mRadioManager.getAmFmRegionConfig());
	LiveData<List<Program>> favorites = mRadioStorage.getFavorites();
	SkipMode skipMode = mRadioStorage.getSkipMode();
	mSkipController = new SkipController(mBinder, favorites, skipMode);
	favorites.observe(this, favs -> mBrowseTree.setFavorites(new HashSet<>(favs)));

	mProgramList = mRadioTuner.getDynamicProgramList(null);
	if (mProgramList != null) {
	mBrowseTree.setProgramList(mProgramList);
	mProgramList.registerListCallback(new ProgramList.ListCallback() {
	@Override
	public void onItemChanged(@NonNull ProgramSelector.Identifier id) {
	onProgramListChanged();
	}
	});
	mProgramList.addOnCompleteListener(this::pushProgramListUpdate);
	}

	mLifecycleRegistry.markState(Lifecycle.State.CREATED);
	}

	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
	Log.d(TAG, "onStartCommand intent [%s] flags[%d] startId[%d]",
	intent.toString(), flags, startId);
	mLifecycleRegistry.markState(Lifecycle.State.STARTED);
	if (BrowseTree.ACTION_PLAY_BROADCASTRADIO.equals(intent.getAction())) {
	Log.i(TAG, "Executing general play radio intent");
	mMediaSession.getController().getTransportControls().playFromMediaId(
	mBrowseTree.getRoot().getRootId(), null);
	return START_NOT_STICKY;
	}

	return super.onStartCommand(intent, flags, startId);
	}

	@Override
	public IBinder onBind(Intent intent) {
	Log.i(TAG, "onBind intent[" + intent + "]");
	mLifecycleRegistry.markState(Lifecycle.State.STARTED);
	if (mRadioTuner == null) return null;
	if (ACTION_APP_SERVICE.equals(intent.getAction())) {
	return mBinder;
	}
	return super.onBind(intent);
	}

	@Override
	public boolean onUnbind(Intent intent) {
	mLifecycleRegistry.markState(Lifecycle.State.CREATED);
	return false;
	}

	@Override
	public void onDestroy() {
	Log.i(TAG, "Shutting down RadioAppService...");

	mLifecycleRegistry.markState(Lifecycle.State.DESTROYED);

	if (mMediaSession != null) mMediaSession.release();
	close();

	super.onDestroy();
	}

	@NonNull
	@Override
	public Lifecycle getLifecycle() {
	return mLifecycleRegistry;
	}

	private void onPlaybackStateChanged(int newState) {
	Log.d(TAG, "onPlaybackStateChanged new state [%d]", newState);
	synchronized (mLock) {
	mCurrentPlaybackState = newState;
	for (IRadioAppCallback callback : mRadioAppCallbacks) {
	tryExec(() -> callback.onPlaybackStateChanged(newState));
	}
	}
	}

	private void onProgramListChanged() {
	if (mProgramList == null) return;
	synchronized (mLock) {
	if (SystemClock.elapsedRealtime() - mLastProgramListPush > PROGRAM_LIST_RATE_LIMITING) {
	pushProgramListUpdate();
	}
	}
	}

	private void pushProgramListUpdate() {
	if (mProgramList == null) return;
	List<ProgramInfo> plist = mProgramList.toList();

	synchronized (mLock) {
	mLastProgramListPush = SystemClock.elapsedRealtime();
	for (IRadioAppCallback callback : mRadioAppCallbacks) {
	tryExec(() -> callback.onProgramListChanged(plist));
	}
	}
	}

	private void tuneToDefault(@Nullable ProgramType pt) {
	synchronized (mLock) {
	if (mRadioTuner == null) throw new IllegalStateException("Tuner session is closed");
	TuneCallback tuneCb = mAudioStreamController.preparePlayback(
	AudioStreamController.OPERATION_TUNE);
	if (tuneCb == null) return;

	ProgramSelector sel = mRadioStorage.getRecentlySelected(pt);
	if (sel != null) {
	Log.i(TAG, "Restoring recently selected program: " + sel);
	try {
	mRadioTuner.tune(sel, tuneCb);
	} catch (IllegalArgumentException \| UnsupportedOperationException e) {
	Log.e(TAG, "Can't restore recently selected program: " + sel, e);
	}
	return;
	}

	if (pt == null) pt = ProgramType.FM;
	Log.i(TAG, "No recently selected program set, selecting default channel for " + pt);
	pt.tuneToDefault(mRadioTuner, mWrapper.getRegionConfig(), tuneCb);
	}
	}

	private void close() {
	synchronized (mLock) {
	if (mAudioStreamController != null) {
	mAudioStreamController.requestMuted(true);
	mAudioStreamController = null;
	}
	if (mProgramList != null) {
	ProgramList oldList = mProgramList;
	mProgramList = null;
	oldList.close();
	}
	if (mRadioTuner != null) {
	mRadioTuner.close();
	mRadioTuner = null;
	}
	}
	}

	@Override
	public BrowserRoot onGetRoot(String clientPackageName, int clientUid, Bundle rootHints) {
	/* Radio application may restrict who can read its MediaBrowser tree.
	* Our implementation doesn't.
	*/
	return mBrowseTree.getRoot();
	}

	@Override
	public void onLoadChildren(final String parentMediaId, final Result<List<MediaItem>> result) {
	mBrowseTree.loadChildren(parentMediaId, result);
	}

	private void onHardwareError() {
	close();
	stopSelf();
	synchronized (mLock) {
	for (IRadioAppCallback callback : mRadioAppCallbacks) {
	tryExec(() -> callback.onHardwareError());
	}
	}
	}

	@Override
	public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
	try (IndentingPrintWriter writer = new IndentingPrintWriter(pw)) {
	pw.println("RadioAppService:");
	writer.increaseIndent();
	if (mSkipController != null) {
	writer.increaseIndent();
	mSkipController.dump(writer);
	writer.decreaseIndent();
	} else {
	pw.println("No SkipController");
	}

	if (mAudioStreamController != null) {
	writer.increaseIndent();
	mAudioStreamController.dump(writer);
	writer.decreaseIndent();
	} else {
	pw.println("No AudioStreamController");
	}
	writer.decreaseIndent();
	}
	}

	private final IRadioAppService.Stub mBinder = new IRadioAppService.Stub() {
	@Override
	public void addCallback(IRadioAppCallback callback) throws RemoteException {
	synchronized (mLock) {
	if (mCurrentProgram != null) callback.onCurrentProgramChanged(mCurrentProgram);
	callback.onPlaybackStateChanged(mCurrentPlaybackState);
	if (mProgramList != null) callback.onProgramListChanged(mProgramList.toList());
	mRadioAppCallbacks.add(callback);
	}
	}

	@Override
	public void removeCallback(IRadioAppCallback callback) {
	synchronized (mLock) {
	mRadioAppCallbacks.remove(callback);
	}
	}

	@Override
	public void tune(ProgramSelector sel, ITuneCallback callback) {
	Objects.requireNonNull(callback);
	synchronized (mLock) {
	if (mRadioTuner == null) throw new IllegalStateException("Tuner session is closed");
	TuneCallback tuneCb = mAudioStreamController.preparePlayback(
	AudioStreamController.OPERATION_TUNE);
	if (tuneCb == null) return;
	mRadioTuner.tune(sel, tuneCb.alsoCall(
	succ -> tryExec(() -> callback.onFinished(succ))));
	}
	}

	@Override
	public void seek(boolean forward, ITuneCallback callback) {
	Objects.requireNonNull(callback);
	synchronized (mLock) {
	if (mRadioTuner == null) throw new IllegalStateException("Tuner session is closed");
	TuneCallback tuneCb = mAudioStreamController.preparePlayback(forward
	? AudioStreamController.OPERATION_SEEK_FWD
	: AudioStreamController.OPERATION_SEEK_BKW);
	if (tuneCb == null) return;
	mRadioTuner.seek(forward, tuneCb.alsoCall(
	succ -> tryExec(() -> callback.onFinished(succ))));
	}
	}

	@Override
	public void skip(boolean forward, ITuneCallback callback) throws RemoteException {
	Objects.requireNonNull(callback);

	mSkipController.skip(forward, callback);
	}

	@Override
	public void setSkipMode(int mode) {
	SkipMode newMode = SkipMode.valueOf(mode);
	if (newMode == null) {
	Log.e(TAG, "setSkipMode(): invalid mode " + mode);
	return;
	}
	mSkipController.setSkipMode(newMode);
	mRadioStorage.setSkipMode(newMode);
	}

	@Override
	public void step(boolean forward, ITuneCallback callback) {
	Objects.requireNonNull(callback);
	synchronized (mLock) {
	if (mRadioTuner == null) throw new IllegalStateException("Tuner session is closed");
	TuneCallback tuneCb = mAudioStreamController.preparePlayback(forward
	? AudioStreamController.OPERATION_STEP_FWD
	: AudioStreamController.OPERATION_STEP_BKW);
	if (tuneCb == null) return;
	mRadioTuner.step(forward, tuneCb.alsoCall(
	succ -> tryExec(() -> callback.onFinished(succ))));
	}
	}

	@Override
	public void setMuted(boolean muted) {
	if (mAudioStreamController == null) return;
	if (muted) mRadioTuner.cancel();
	mAudioStreamController.requestMuted(muted);
	}

	@Override
	public void tuneToDefaultIfNeeded() {
	synchronized (mLock) {
	if (mRadioTuner == null) {
	throw new IllegalStateException("Tuner session is closed");
	}

	if (mCurrentPlaybackState != PlaybackState.STATE_NONE) {
	return;
	}
	}

	tuneToDefault(null);
	}

	@Override
	public void switchBand(ProgramType band) {
	tuneToDefault(band);
	}

	@Override
	public boolean isProgramListSupported() {
	return mProgramList != null;
	}

	@Override
	public RegionConfig getRegionConfig() {
	synchronized (mLock) {
	if (mRegionConfigCache == null) {
	mRegionConfigCache = new RegionConfig(mRadioManager.getAmFmRegionConfig());
	}
	return mRegionConfigCache;
	}
	}
	};

	private RadioTuner.Callback mHardwareCallback = new RadioTuner.Callback() {
	@Override
	public void onProgramInfoChanged(ProgramInfo info) {
	Objects.requireNonNull(info);

	Log.d(TAG, "Program info changed: %s", info);

	synchronized (mLock) {
	mCurrentProgram = info;

	/* Storing recently selected program might be limited to explicit tune calls only
	* (including next/prev seek), but the implementation would be nontrivial with the
	* current API. For now, let's make it simple and make it react to all program
	* selector changes. */
	mRadioStorage.setRecentlySelected(info.getSelector());
	for (IRadioAppCallback callback : mRadioAppCallbacks) {
	tryExec(() -> callback.onCurrentProgramChanged(info));
	}
	}
	}

	@Override
	public void onError(int status) {
	switch (status) {
	case RadioTuner.ERROR_HARDWARE_FAILURE:
	case RadioTuner.ERROR_SERVER_DIED:
	Log.e(TAG, "Fatal hardware error: " + status);
	onHardwareError();
	break;
	default:
	Log.w(TAG, "Hardware error: " + status);
	}
	}

	@Override
	public void onControlChanged(boolean control) {
	if (!control) onHardwareError();
	}
	};
	}