src/com/android/car/radio/service/RadioAppServiceWrapper.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 android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
 import android.hardware.radio.ProgramSelector;
 import android.hardware.radio.RadioManager.ProgramInfo;
 import android.media.session.PlaybackState;
 import android.os.IBinder;
 import android.os.RemoteException;

 import androidx.annotation.IntDef;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.lifecycle.LiveData;
 import androidx.lifecycle.MutableLiveData;

 import com.android.car.radio.SkipMode;
 import com.android.car.radio.bands.ProgramType;
 import com.android.car.radio.bands.RegionConfig;
 import com.android.car.radio.platform.RadioTunerExt.TuneCallback;
 import com.android.car.radio.util.Log;

 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.util.List;
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicReference;

 /**
  * {@link IRadioAppService} wrapper to abstract out some nuances of interactions
  * with remote services.
  */
 public class RadioAppServiceWrapper {
     private static final String TAG = "BcRadioApp.servicewr";

     /**
      * Binding has just been requested and we're connecting to the {@link RadioAppService} now.
      */
     public static final int STATE_CONNECTING = 1;

     /**
      * {@link RadioAppService} connection is up and running.
      */
     public static final int STATE_CONNECTED = 2;

     /**
      * This device has no broadcastradio hardware.
      */
     public static final int STATE_NOT_SUPPORTED = 3;

     /**
      * Some problem has occured (either RadioAppService crashed or there was HW problem).
      */
     public static final int STATE_ERROR = 4;

     /**
      * Application state.
      */
     @IntDef(value = {
         STATE_CONNECTING,
         STATE_CONNECTED,
         STATE_NOT_SUPPORTED,
         STATE_ERROR,
     })
     @Retention(RetentionPolicy.SOURCE)
     public @interface ConnectionState {}

     private Context mClientContext;
     @Nullable
     private final AtomicReference<IRadioAppService> mService = new AtomicReference<>();
     private final Object mLock = new Object();

     private final MutableLiveData<Integer> mConnectionState = new MutableLiveData<>();
     private final MutableLiveData<Integer> mPlaybackState = new MutableLiveData<>();
     private final MutableLiveData<ProgramInfo> mCurrentProgram = new MutableLiveData<>();
     private final MutableLiveData<List<ProgramInfo>> mProgramList = new MutableLiveData<>();

     {
         mConnectionState.postValue(STATE_CONNECTING);
         mPlaybackState.postValue(PlaybackState.STATE_NONE);
     }

     private static class TuneCallbackAdapter extends ITuneCallback.Stub {
         private final TuneCallback mCallback;

         private TuneCallbackAdapter(@Nullable TuneCallback cb) {
             mCallback = cb;
         }

         public void onFinished(boolean succeeded) {
             if (mCallback != null) mCallback.onFinished(succeeded);
         }
     }

     /**
      * Wraps remote service instance.
      *
      * You must call {@link #bind} once the context is available.
      */
     public RadioAppServiceWrapper() {}

     /**
      * Wraps existing (local) service instance.
      *
      * For use by the RadioAppService itself.
      */
     public RadioAppServiceWrapper(@NonNull IRadioAppService service) {
         Objects.requireNonNull(service);
         mService.set(service);
         initialize(service);
     }

     private void initialize(@NonNull IRadioAppService service) {
         try {
             service.addCallback(mCallback);
         } catch (RemoteException e) {
             throw new RuntimeException("Wrapper initialization failed", e);
         }
     }

     private final ServiceConnection mServiceConnection = new ServiceConnection() {
         @Override
         public void onServiceConnected(ComponentName className, IBinder binder) {
             RadioAppServiceWrapper.this.onServiceConnected(binder,
                     Objects.requireNonNull(IRadioAppService.Stub.asInterface(binder)));
         }

         @Override
         public void onServiceDisconnected(ComponentName className) {
             onServiceFailure();
         }

         @Override
         public void onBindingDied(ComponentName name) {
             onServiceFailure();
         }

         @Override
         public void onNullBinding(ComponentName name) {
             RadioAppServiceWrapper.this.onNullBinding();
         }
     };

     private final IRadioAppCallback mCallback = new IRadioAppCallback.Stub() {
         @Override
         public void onHardwareError() {
             onServiceFailure();
         }

         @Override
         public void onCurrentProgramChanged(ProgramInfo info) {
             mCurrentProgram.postValue(info);
         }

         @Override
         public void onPlaybackStateChanged(int state) {
             mPlaybackState.postValue(state);
         }

         @Override
         public void onProgramListChanged(List<ProgramInfo> plist) {
             mProgramList.postValue(plist);
         }
     };

     /**
      * Binds to running {@link RadioAppService} instance or starts one if it doesn't exist.
      */
     public void bind(@NonNull Context context) {
         mClientContext = Objects.requireNonNull(context);

         Intent bindIntent = new Intent(RadioAppService.ACTION_APP_SERVICE, null,
                 context, RadioAppService.class);
         if (!context.bindService(bindIntent, mServiceConnection, Context.BIND_AUTO_CREATE)) {
             throw new RuntimeException("Failed to bind to RadioAppService");
         }
     }

     /**
      * Unbinds from remote radio service.
      */
     public void unbind() {
         if (mClientContext == null) {
             throw new IllegalStateException(
                     "This is not a remote service wrapper, you can't unbind it");
         }
         try {
             callService(service -> service.removeCallback(mCallback));
         } catch (IllegalStateException e) { }  // it's fine if the service is not connected
         mClientContext.unbindService(mServiceConnection);
     }

     private void onServiceConnected(IBinder binder, @NonNull IRadioAppService service) {
         Log.d(TAG, "RadioAppService connected");
         mService.set(service);
         initialize(service);
         mConnectionState.postValue(STATE_CONNECTED);
     }

     private void onServiceFailure() {
         if (mService.getAndSet(null) == null) return;
         Log.e(TAG, "RadioAppService failed " + (mClientContext == null ? "(local)" : "(remote)"));
         mConnectionState.postValue(STATE_ERROR);
     }

     private void onNullBinding() {
         Log.i(TAG, "RadioAppService is not accepting connections. "
                 + "It means the radio hardware is not available");
         mClientContext.unbindService(mServiceConnection);
         mConnectionState.postValue(STATE_NOT_SUPPORTED);
     }

     private interface ServiceVoidOperation {
         void execute(@NonNull IRadioAppService service) throws RemoteException;
     }

     private interface ServiceOperation<V> {
         V execute(@NonNull IRadioAppService service) throws RemoteException;
     }

     private <V> V queryService(@NonNull ServiceOperation<V> op, V defaultResponse) {
         IRadioAppService service = mService.get();
         if (service == null) {
             throw new IllegalStateException("Service is not connected");
         }
         try {
             return op.execute(service);
         } catch (RemoteException e) {
             Log.e(TAG, "Remote call failed", e);
             onServiceFailure();
             return defaultResponse;
         }
     }

     private void callService(@NonNull ServiceVoidOperation op) {
         IRadioAppService service = mService.get();
         if (service == null) {
             throw new IllegalStateException("Service is not connected");
         }
         try {
             op.execute(service);
         } catch (RemoteException e) {
             Log.e(TAG, "Remote call failed", e);
             onServiceFailure();
         }
     }

     /**
      * Returns a {@link LiveData} stating if the {@link RadioAppService} connection state.
      *
      * @see {@link ConnectionState}.
      */
     @NonNull
     public LiveData<Integer> getConnectionState() {
         return mConnectionState;
     }

     /**
      * Returns a {@link LiveData} containing playback state.
      */
     @NonNull
     public LiveData<Integer> getPlaybackState() {
         return mPlaybackState;
     }

     /**
      * Returns a {@link LiveData} containing currently tuned program info.
      */
     @NonNull
     public LiveData<ProgramInfo> getCurrentProgram() {
         return mCurrentProgram;
     }

     /**
      * Returns a {@link LiveData} containing programs list found by the background tuner.
      *
      * @return Program list container, or {@code null} if program list is not supported
      */
     @NonNull
     public LiveData<List<ProgramInfo>> getProgramList() {
         return mProgramList;
     }

     /**
      * Tunes to a given program.
      */
     public void tune(@NonNull ProgramSelector sel) {
         tune(sel, null);
     }

     /**
      * Tunes to a given program with a callback.
      */
     public void tune(@NonNull ProgramSelector sel, @Nullable TuneCallback result) {
         callService(service -> service.tune(sel, new TuneCallbackAdapter(result)));
     }

     /**
      * Seeks forward/backwards.
      */
     public void seek(boolean forward) {
         seek(forward, null);
     }

     /**
      * Seeks forward/backwards with a callback.
      */
     public void seek(boolean forward, @Nullable TuneCallback result) {
         callService(service -> service.seek(forward, new TuneCallbackAdapter(result)));
     }

     /**
      * Skips forward/backwards.
      */
     public void skip(boolean forward) {
         callService(service -> service.skip(forward, new TuneCallbackAdapter(null)));
     }

     /**
      * Sets the service's {@link SkipMode} mode.
      */
     public void setSkipMode(@NonNull SkipMode mode) {
         callService(service -> service.setSkipMode(mode.ordinal()));
     }

     /**
      * Steps forward/backwards
      */
     public void step(boolean forward) {
         step(forward, null);
     }

     /**
      * Steps forward/backwards with a callback.
      */
     public void step(boolean forward, @Nullable TuneCallback result) {
         callService(service -> service.step(forward, new TuneCallbackAdapter(result)));
     }

     /**
      * Mutes or resumes audio.
      *
      * @param muted {@code true} to mute, {@code false} to resume audio.
      */
     public void setMuted(boolean muted) {
         callService(service -> service.setMuted(muted));
     }

     /**
      * Tunes to the previously selected program or the default channel.
      */
     public void tuneToDefaultIfNeeded() {
         callService(service -> service.tuneToDefaultIfNeeded());
     }

     /**
      * Tune to a default channel of a given program type (band).
      *
      * Usually, this means tuning to the recently listened program of a given band.
      *
      * @param band Program type to switch to
      */
     public void switchBand(@NonNull ProgramType band) {
         callService(service -> service.switchBand(Objects.requireNonNull(band)));
     }

     /**
      * States whether program list is supported on current device or not.
      *
      * @return {@code true} if the program list is supported, {@code false} otherwise.
      */
     public boolean isProgramListSupported() {
         return queryService(service -> service.isProgramListSupported(), false);
     }

     /**
      * Returns current region config (like frequency ranges for AM/FM).
      */
     @NonNull
     public RegionConfig getRegionConfig() {
         return Objects.requireNonNull(queryService(service -> service.getRegionConfig(), null));
     }
 }
	/**
	* 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 android.content.ComponentName;
	import android.content.Context;
	import android.content.Intent;
	import android.content.ServiceConnection;
	import android.hardware.radio.ProgramSelector;
	import android.hardware.radio.RadioManager.ProgramInfo;
	import android.media.session.PlaybackState;
	import android.os.IBinder;
	import android.os.RemoteException;

	import androidx.annotation.IntDef;
	import androidx.annotation.NonNull;
	import androidx.annotation.Nullable;
	import androidx.lifecycle.LiveData;
	import androidx.lifecycle.MutableLiveData;

	import com.android.car.radio.SkipMode;
	import com.android.car.radio.bands.ProgramType;
	import com.android.car.radio.bands.RegionConfig;
	import com.android.car.radio.platform.RadioTunerExt.TuneCallback;
	import com.android.car.radio.util.Log;

	import java.lang.annotation.Retention;
	import java.lang.annotation.RetentionPolicy;
	import java.util.List;
	import java.util.Objects;
	import java.util.concurrent.atomic.AtomicReference;

	/**
	* {@link IRadioAppService} wrapper to abstract out some nuances of interactions
	* with remote services.
	*/
	public class RadioAppServiceWrapper {
	private static final String TAG = "BcRadioApp.servicewr";

	/**
	* Binding has just been requested and we're connecting to the {@link RadioAppService} now.
	*/
	public static final int STATE_CONNECTING = 1;

	/**
	* {@link RadioAppService} connection is up and running.
	*/
	public static final int STATE_CONNECTED = 2;

	/**
	* This device has no broadcastradio hardware.
	*/
	public static final int STATE_NOT_SUPPORTED = 3;

	/**
	* Some problem has occured (either RadioAppService crashed or there was HW problem).
	*/
	public static final int STATE_ERROR = 4;

	/**
	* Application state.
	*/
	@IntDef(value = {
	STATE_CONNECTING,
	STATE_CONNECTED,
	STATE_NOT_SUPPORTED,
	STATE_ERROR,
	})
	@Retention(RetentionPolicy.SOURCE)
	public @interface ConnectionState {}

	private Context mClientContext;
	@Nullable
	private final AtomicReference<IRadioAppService> mService = new AtomicReference<>();
	private final Object mLock = new Object();

	private final MutableLiveData<Integer> mConnectionState = new MutableLiveData<>();
	private final MutableLiveData<Integer> mPlaybackState = new MutableLiveData<>();
	private final MutableLiveData<ProgramInfo> mCurrentProgram = new MutableLiveData<>();
	private final MutableLiveData<List<ProgramInfo>> mProgramList = new MutableLiveData<>();

	{
	mConnectionState.postValue(STATE_CONNECTING);
	mPlaybackState.postValue(PlaybackState.STATE_NONE);
	}

	private static class TuneCallbackAdapter extends ITuneCallback.Stub {
	private final TuneCallback mCallback;

	private TuneCallbackAdapter(@Nullable TuneCallback cb) {
	mCallback = cb;
	}

	public void onFinished(boolean succeeded) {
	if (mCallback != null) mCallback.onFinished(succeeded);
	}
	}

	/**
	* Wraps remote service instance.
	*
	* You must call {@link #bind} once the context is available.
	*/
	public RadioAppServiceWrapper() {}

	/**
	* Wraps existing (local) service instance.
	*
	* For use by the RadioAppService itself.
	*/
	public RadioAppServiceWrapper(@NonNull IRadioAppService service) {
	Objects.requireNonNull(service);
	mService.set(service);
	initialize(service);
	}

	private void initialize(@NonNull IRadioAppService service) {
	try {
	service.addCallback(mCallback);
	} catch (RemoteException e) {
	throw new RuntimeException("Wrapper initialization failed", e);
	}
	}

	private final ServiceConnection mServiceConnection = new ServiceConnection() {
	@Override
	public void onServiceConnected(ComponentName className, IBinder binder) {
	RadioAppServiceWrapper.this.onServiceConnected(binder,
	Objects.requireNonNull(IRadioAppService.Stub.asInterface(binder)));
	}

	@Override
	public void onServiceDisconnected(ComponentName className) {
	onServiceFailure();
	}

	@Override
	public void onBindingDied(ComponentName name) {
	onServiceFailure();
	}

	@Override
	public void onNullBinding(ComponentName name) {
	RadioAppServiceWrapper.this.onNullBinding();
	}
	};

	private final IRadioAppCallback mCallback = new IRadioAppCallback.Stub() {
	@Override
	public void onHardwareError() {
	onServiceFailure();
	}

	@Override
	public void onCurrentProgramChanged(ProgramInfo info) {
	mCurrentProgram.postValue(info);
	}

	@Override
	public void onPlaybackStateChanged(int state) {
	mPlaybackState.postValue(state);
	}

	@Override
	public void onProgramListChanged(List<ProgramInfo> plist) {
	mProgramList.postValue(plist);
	}
	};

	/**
	* Binds to running {@link RadioAppService} instance or starts one if it doesn't exist.
	*/
	public void bind(@NonNull Context context) {
	mClientContext = Objects.requireNonNull(context);

	Intent bindIntent = new Intent(RadioAppService.ACTION_APP_SERVICE, null,
	context, RadioAppService.class);
	if (!context.bindService(bindIntent, mServiceConnection, Context.BIND_AUTO_CREATE)) {
	throw new RuntimeException("Failed to bind to RadioAppService");
	}
	}

	/**
	* Unbinds from remote radio service.
	*/
	public void unbind() {
	if (mClientContext == null) {
	throw new IllegalStateException(
	"This is not a remote service wrapper, you can't unbind it");
	}
	try {
	callService(service -> service.removeCallback(mCallback));
	} catch (IllegalStateException e) { } // it's fine if the service is not connected
	mClientContext.unbindService(mServiceConnection);
	}

	private void onServiceConnected(IBinder binder, @NonNull IRadioAppService service) {
	Log.d(TAG, "RadioAppService connected");
	mService.set(service);
	initialize(service);
	mConnectionState.postValue(STATE_CONNECTED);
	}

	private void onServiceFailure() {
	if (mService.getAndSet(null) == null) return;
	Log.e(TAG, "RadioAppService failed " + (mClientContext == null ? "(local)" : "(remote)"));
	mConnectionState.postValue(STATE_ERROR);
	}

	private void onNullBinding() {
	Log.i(TAG, "RadioAppService is not accepting connections. "
	+ "It means the radio hardware is not available");
	mClientContext.unbindService(mServiceConnection);
	mConnectionState.postValue(STATE_NOT_SUPPORTED);
	}

	private interface ServiceVoidOperation {
	void execute(@NonNull IRadioAppService service) throws RemoteException;
	}

	private interface ServiceOperation<V> {
	V execute(@NonNull IRadioAppService service) throws RemoteException;
	}

	private <V> V queryService(@NonNull ServiceOperation<V> op, V defaultResponse) {
	IRadioAppService service = mService.get();
	if (service == null) {
	throw new IllegalStateException("Service is not connected");
	}
	try {
	return op.execute(service);
	} catch (RemoteException e) {
	Log.e(TAG, "Remote call failed", e);
	onServiceFailure();
	return defaultResponse;
	}
	}

	private void callService(@NonNull ServiceVoidOperation op) {
	IRadioAppService service = mService.get();
	if (service == null) {
	throw new IllegalStateException("Service is not connected");
	}
	try {
	op.execute(service);
	} catch (RemoteException e) {
	Log.e(TAG, "Remote call failed", e);
	onServiceFailure();
	}
	}

	/**
	* Returns a {@link LiveData} stating if the {@link RadioAppService} connection state.
	*
	* @see {@link ConnectionState}.
	*/
	@NonNull
	public LiveData<Integer> getConnectionState() {
	return mConnectionState;
	}

	/**
	* Returns a {@link LiveData} containing playback state.
	*/
	@NonNull
	public LiveData<Integer> getPlaybackState() {
	return mPlaybackState;
	}

	/**
	* Returns a {@link LiveData} containing currently tuned program info.
	*/
	@NonNull
	public LiveData<ProgramInfo> getCurrentProgram() {
	return mCurrentProgram;
	}

	/**
	* Returns a {@link LiveData} containing programs list found by the background tuner.
	*
	* @return Program list container, or {@code null} if program list is not supported
	*/
	@NonNull
	public LiveData<List<ProgramInfo>> getProgramList() {
	return mProgramList;
	}

	/**
	* Tunes to a given program.
	*/
	public void tune(@NonNull ProgramSelector sel) {
	tune(sel, null);
	}

	/**
	* Tunes to a given program with a callback.
	*/
	public void tune(@NonNull ProgramSelector sel, @Nullable TuneCallback result) {
	callService(service -> service.tune(sel, new TuneCallbackAdapter(result)));
	}

	/**
	* Seeks forward/backwards.
	*/
	public void seek(boolean forward) {
	seek(forward, null);
	}

	/**
	* Seeks forward/backwards with a callback.
	*/
	public void seek(boolean forward, @Nullable TuneCallback result) {
	callService(service -> service.seek(forward, new TuneCallbackAdapter(result)));
	}

	/**
	* Skips forward/backwards.
	*/
	public void skip(boolean forward) {
	callService(service -> service.skip(forward, new TuneCallbackAdapter(null)));
	}

	/**
	* Sets the service's {@link SkipMode} mode.
	*/
	public void setSkipMode(@NonNull SkipMode mode) {
	callService(service -> service.setSkipMode(mode.ordinal()));
	}

	/**
	* Steps forward/backwards
	*/
	public void step(boolean forward) {
	step(forward, null);
	}

	/**
	* Steps forward/backwards with a callback.
	*/
	public void step(boolean forward, @Nullable TuneCallback result) {
	callService(service -> service.step(forward, new TuneCallbackAdapter(result)));
	}

	/**
	* Mutes or resumes audio.
	*
	* @param muted {@code true} to mute, {@code false} to resume audio.
	*/
	public void setMuted(boolean muted) {
	callService(service -> service.setMuted(muted));
	}

	/**
	* Tunes to the previously selected program or the default channel.
	*/
	public void tuneToDefaultIfNeeded() {
	callService(service -> service.tuneToDefaultIfNeeded());
	}

	/**
	* Tune to a default channel of a given program type (band).
	*
	* Usually, this means tuning to the recently listened program of a given band.
	*
	* @param band Program type to switch to
	*/
	public void switchBand(@NonNull ProgramType band) {
	callService(service -> service.switchBand(Objects.requireNonNull(band)));
	}

	/**
	* States whether program list is supported on current device or not.
	*
	* @return {@code true} if the program list is supported, {@code false} otherwise.
	*/
	public boolean isProgramListSupported() {
	return queryService(service -> service.isProgramListSupported(), false);
	}

	/**
	* Returns current region config (like frequency ranges for AM/FM).
	*/
	@NonNull
	public RegionConfig getRegionConfig() {
	return Objects.requireNonNull(queryService(service -> service.getRegionConfig(), null));
	}
	}