Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "broadcast radio API"

Browse Source
This commit is contained in:
Eric Laurent
2015-03-16 18:30:21 +00:00
committed by Android (Google) Code Review
parent d92e28255e 2035ac85f6
commit aff57b7519
7 changed files with 2486 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

189
api/system-current.txt
View File

@@ -14189,6 +14189,195 @@ package android.hardware.location {
}
package android.hardware.radio {
public class RadioManager {
method public int listModules(java.util.List<android.hardware.radio.RadioManager.ModuleProperties>);
method public android.hardware.radio.RadioTuner openTuner(int, android.hardware.radio.RadioManager.BandConfig, boolean, android.hardware.radio.RadioTuner.Callback, android.os.Handler);
field public static final int BAND_AM = 0; // 0x0
field public static final int BAND_AM_HD = 3; // 0x3
field public static final int BAND_FM = 1; // 0x1
field public static final int BAND_FM_HD = 2; // 0x2
field public static final int CLASS_AM_FM = 0; // 0x0
field public static final int CLASS_DT = 2; // 0x2
field public static final int CLASS_SAT = 1; // 0x1
field public static final int REGION_ITU_1 = 0; // 0x0
field public static final int REGION_ITU_2 = 1; // 0x1
field public static final int REGION_JAPAN = 3; // 0x3
field public static final int REGION_KOREA = 4; // 0x4
field public static final int REGION_OIRT = 2; // 0x2
field public static final int STATUS_BAD_VALUE = -22; // 0xffffffea
field public static final int STATUS_DEAD_OBJECT = -32; // 0xffffffe0
field public static final int STATUS_ERROR = -2147483648; // 0x80000000
field public static final int STATUS_INVALID_OPERATION = -38; // 0xffffffda
field public static final int STATUS_NO_INIT = -19; // 0xffffffed
field public static final int STATUS_OK = 0; // 0x0
field public static final int STATUS_PERMISSION_DENIED = -1; // 0xffffffff
field public static final int STATUS_TIMED_OUT = -110; // 0xffffff92
}
public static class RadioManager.AmBandConfig extends android.hardware.radio.RadioManager.BandConfig {
method public boolean getStereo();
field public static final android.os.Parcelable.Creator<android.hardware.radio.RadioManager.AmBandConfig> CREATOR;
}
public static class RadioManager.AmBandConfig.Builder {
ctor public RadioManager.AmBandConfig.Builder(android.hardware.radio.RadioManager.AmBandDescriptor);
ctor public RadioManager.AmBandConfig.Builder(android.hardware.radio.RadioManager.AmBandConfig);
method public android.hardware.radio.RadioManager.AmBandConfig build();
method public android.hardware.radio.RadioManager.AmBandConfig.Builder setStereo(boolean);
}
public static class RadioManager.AmBandDescriptor extends android.hardware.radio.RadioManager.BandDescriptor {
method public boolean isStereoSupported();
field public static final android.os.Parcelable.Creator<android.hardware.radio.RadioManager.AmBandDescriptor> CREATOR;
}
public static class RadioManager.BandConfig implements android.os.Parcelable {
method public int describeContents();
method public int getLowerLimit();
method public int getRegion();
method public int getSpacing();
method public int getType();
method public int getUpperLimit();
method public void writeToParcel(android.os.Parcel, int);
field public static final android.os.Parcelable.Creator<android.hardware.radio.RadioManager.BandConfig> CREATOR;
}
public static class RadioManager.BandDescriptor implements android.os.Parcelable {
method public int describeContents();
method public int getLowerLimit();
method public int getRegion();
method public int getSpacing();
method public int getType();
method public int getUpperLimit();
method public void writeToParcel(android.os.Parcel, int);
field public static final android.os.Parcelable.Creator<android.hardware.radio.RadioManager.BandDescriptor> CREATOR;
}
public static class RadioManager.FmBandConfig extends android.hardware.radio.RadioManager.BandConfig {
method public boolean getAf();
method public boolean getRds();
method public boolean getStereo();
method public boolean getTa();
field public static final android.os.Parcelable.Creator<android.hardware.radio.RadioManager.FmBandConfig> CREATOR;
}
public static class RadioManager.FmBandConfig.Builder {
ctor public RadioManager.FmBandConfig.Builder(android.hardware.radio.RadioManager.FmBandDescriptor);
ctor public RadioManager.FmBandConfig.Builder(android.hardware.radio.RadioManager.FmBandConfig);
method public android.hardware.radio.RadioManager.FmBandConfig build();
method public android.hardware.radio.RadioManager.FmBandConfig.Builder setAf(boolean);
method public android.hardware.radio.RadioManager.FmBandConfig.Builder setRds(boolean);
method public android.hardware.radio.RadioManager.FmBandConfig.Builder setStereo(boolean);
method public android.hardware.radio.RadioManager.FmBandConfig.Builder setTa(boolean);
}
public static class RadioManager.FmBandDescriptor extends android.hardware.radio.RadioManager.BandDescriptor {
method public boolean isAfSupported();
method public boolean isRdsSupported();
method public boolean isStereoSupported();
method public boolean isTaSupported();
field public static final android.os.Parcelable.Creator<android.hardware.radio.RadioManager.FmBandDescriptor> CREATOR;
}
public static class RadioManager.ModuleProperties implements android.os.Parcelable {
method public int describeContents();
method public android.hardware.radio.RadioManager.BandDescriptor[] getBands();
method public int getClassId();
method public int getId();
method public java.lang.String getImplementor();
method public int getNumAudioSources();
method public int getNumTuners();
method public java.lang.String getProduct();
method public java.lang.String getSerial();
method public java.lang.String getVersion();
method public boolean isCaptureSupported();
method public void writeToParcel(android.os.Parcel, int);
field public static final android.os.Parcelable.Creator<android.hardware.radio.RadioManager.ModuleProperties> CREATOR;
}
public static class RadioManager.ProgramInfo implements android.os.Parcelable {
method public int describeContents();
method public int getChannel();
method public android.hardware.radio.RadioMetadata getMetadata();
method public int getSignalStrength();
method public int getSubChannel();
method public boolean isDigital();
method public boolean isStereo();
method public boolean isTuned();
method public void writeToParcel(android.os.Parcel, int);
field public static final android.os.Parcelable.Creator<android.hardware.radio.RadioManager.ProgramInfo> CREATOR;
}
public final class RadioMetadata implements android.os.Parcelable {
method public boolean containsKey(java.lang.String);
method public int describeContents();
method public android.graphics.Bitmap getBitmap(java.lang.String);
method public int getInt(java.lang.String);
method public java.lang.String getString(java.lang.String);
method public java.util.Set<java.lang.String> keySet();
method public int size();
method public void writeToParcel(android.os.Parcel, int);
field public static final android.os.Parcelable.Creator<android.hardware.radio.RadioMetadata> CREATOR;
field public static final java.lang.String METADATA_KEY_ALBUM = "android.hardware.radio.metadata.ALBUM";
field public static final java.lang.String METADATA_KEY_ART = "android.hardware.radio.metadata.ART";
field public static final java.lang.String METADATA_KEY_ARTIST = "android.hardware.radio.metadata.ARTIST";
field public static final java.lang.String METADATA_KEY_GENRE = "android.hardware.radio.metadata.GENRE";
field public static final java.lang.String METADATA_KEY_ICON = "android.hardware.radio.metadata.ICON";
field public static final java.lang.String METADATA_KEY_RBDS_PTY = "android.hardware.radio.metadata.RBDS_PTY";
field public static final java.lang.String METADATA_KEY_RDS_PI = "android.hardware.radio.metadata.RDS_PI";
field public static final java.lang.String METADATA_KEY_RDS_PS = "android.hardware.radio.metadata.RDS_PS";
field public static final java.lang.String METADATA_KEY_RDS_PTY = "android.hardware.radio.metadata.RDS_PTY";
field public static final java.lang.String METADATA_KEY_RDS_RT = "android.hardware.radio.metadata.RDS_RT";
field public static final java.lang.String METADATA_KEY_TITLE = "android.hardware.radio.metadata.TITLE";
}
public static final class RadioMetadata.Builder {
ctor public RadioMetadata.Builder();
ctor public RadioMetadata.Builder(android.hardware.radio.RadioMetadata);
method public android.hardware.radio.RadioMetadata build();
method public android.hardware.radio.RadioMetadata.Builder putBitmap(java.lang.String, android.graphics.Bitmap);
method public android.hardware.radio.RadioMetadata.Builder putInt(java.lang.String, int);
method public android.hardware.radio.RadioMetadata.Builder putString(java.lang.String, java.lang.String);
}
public abstract class RadioTuner {
ctor public RadioTuner();
method public abstract int cancel();
method public abstract void close();
method public abstract int getConfiguration(android.hardware.radio.RadioManager.BandConfig[]);
method public abstract boolean getMute();
method public abstract int getProgramInformation(android.hardware.radio.RadioManager.ProgramInfo[]);
method public abstract boolean hasControl();
method public abstract boolean isAntennaConnected();
method public abstract int scan(int, boolean);
method public abstract int setConfiguration(android.hardware.radio.RadioManager.BandConfig);
method public abstract int setMute(boolean);
method public abstract int step(int, boolean);
method public abstract int tune(int, int);
field public static final int DIRECTION_DOWN = 1; // 0x1
field public static final int DIRECTION_UP = 0; // 0x0
field public static final int ERROR_CANCELLED = 2; // 0x2
field public static final int ERROR_CONFIG = 4; // 0x4
field public static final int ERROR_HARDWARE_FAILURE = 0; // 0x0
field public static final int ERROR_SCAN_TIMEOUT = 3; // 0x3
field public static final int ERROR_SERVER_DIED = 1; // 0x1
}
public static abstract class RadioTuner.Callback {
ctor public RadioTuner.Callback();
method public void onAntennaState(boolean);
method public void onConfigurationChanged(android.hardware.radio.RadioManager.BandConfig);
method public void onControlChanged(boolean);
method public void onError(int);
method public void onMetadataChanged(android.hardware.radio.RadioMetadata);
method public void onProgramInfoChanged(android.hardware.radio.RadioManager.ProgramInfo);
method public void onTrafficAnnouncement(boolean);
}
}
package android.hardware.usb {
public class UsbAccessory implements android.os.Parcelable {

8
core/java/android/app/SystemServiceRegistry.java
View File

@@ -49,6 +49,7 @@ import android.hardware.hdmi.IHdmiControlService;
import android.hardware.input.InputManager;
import android.hardware.usb.IUsbManager;
import android.hardware.usb.UsbManager;
import android.hardware.radio.RadioManager;
import android.location.CountryDetector;
import android.location.ICountryDetector;
import android.location.ILocationManager;
@@ -683,6 +684,13 @@ final class SystemServiceRegistry {
IBinder b = ServiceManager.getService(Context.MIDI_SERVICE);
return new MidiManager(ctx, IMidiManager.Stub.asInterface(b));
}});
registerService(Context.RADIO_SERVICE, RadioManager.class,
new CachedServiceFetcher<RadioManager>() {
@Override
public RadioManager createService(ContextImpl ctx) {
return new RadioManager(ctx);
}});
}
/**

12
core/java/android/content/Context.java
View File

@@ -2200,6 +2200,7 @@ public abstract class Context {
//@hide: PERSISTENT_DATA_BLOCK_SERVICE,
MEDIA_PROJECTION_SERVICE,
MIDI_SERVICE,
RADIO_SERVICE,
})
@Retention(RetentionPolicy.SOURCE)
public @interface ServiceName {}
@@ -3026,6 +3027,17 @@ public abstract class Context {
*/
public static final String MIDI_SERVICE = "midi";
/**
* Use with {@link #getSystemService} to retrieve a
* {@link android.hardware.radio.RadioManager} for accessing the broadcast radio service.
*
* @see #getSystemService
* @hide
*/
public static final String RADIO_SERVICE = "radio";
/**
* Determine whether the given permission is allowed for a particular
* process and user ID running in the system.

1308
core/java/android/hardware/radio/RadioManager.java Normal file
View File

File diff suppressed because it is too large Load Diff

449
core/java/android/hardware/radio/RadioMetadata.java Normal file
View File

@@ -0,0 +1,449 @@
/*
* Copyright (C) 2015 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 android.hardware.radio;
import android.annotation.NonNull;
import android.annotation.SystemApi;
import android.content.ContentResolver;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
import android.text.TextUtils;
import android.util.ArrayMap;
import android.util.Log;
import android.util.SparseArray;
import java.util.ArrayList;
import java.util.Set;
/**
* Contains meta data about a radio program such as station name, song title, artist etc...
* @hide
*/
@SystemApi
public final class RadioMetadata implements Parcelable {
private static final String TAG = "RadioMetadata";
/**
* The RDS Program Information.
*/
public static final String METADATA_KEY_RDS_PI = "android.hardware.radio.metadata.RDS_PI";
/**
* The RDS Program Service.
*/
public static final String METADATA_KEY_RDS_PS = "android.hardware.radio.metadata.RDS_PS";
/**
* The RDS PTY.
*/
public static final String METADATA_KEY_RDS_PTY = "android.hardware.radio.metadata.RDS_PTY";
/**
* The RBDS PTY.
*/
public static final String METADATA_KEY_RBDS_PTY = "android.hardware.radio.metadata.RBDS_PTY";
/**
* The RBDS Radio Text.
*/
public static final String METADATA_KEY_RDS_RT = "android.hardware.radio.metadata.RDS_RT";
/**
* The song title.
*/
public static final String METADATA_KEY_TITLE = "android.hardware.radio.metadata.TITLE";
/**
* The artist name.
*/
public static final String METADATA_KEY_ARTIST = "android.hardware.radio.metadata.ARTIST";
/**
* The album name.
*/
public static final String METADATA_KEY_ALBUM = "android.hardware.radio.metadata.ALBUM";
/**
* The music genre.
*/
public static final String METADATA_KEY_GENRE = "android.hardware.radio.metadata.GENRE";
/**
* The radio station icon {@link Bitmap}.
*/
public static final String METADATA_KEY_ICON = "android.hardware.radio.metadata.ICON";
/**
* The artwork for the song/album {@link Bitmap}.
*/
public static final String METADATA_KEY_ART = "android.hardware.radio.metadata.ART";
private static final int METADATA_TYPE_INVALID = -1;
private static final int METADATA_TYPE_INT = 0;
private static final int METADATA_TYPE_TEXT = 1;
private static final int METADATA_TYPE_BITMAP = 2;
private static final ArrayMap<String, Integer> METADATA_KEYS_TYPE;
static {
METADATA_KEYS_TYPE = new ArrayMap<String, Integer>();
METADATA_KEYS_TYPE.put(METADATA_KEY_RDS_PI, METADATA_TYPE_TEXT);
METADATA_KEYS_TYPE.put(METADATA_KEY_RDS_PS, METADATA_TYPE_TEXT);
METADATA_KEYS_TYPE.put(METADATA_KEY_RDS_PTY, METADATA_TYPE_INT);
METADATA_KEYS_TYPE.put(METADATA_KEY_RBDS_PTY, METADATA_TYPE_INT);
METADATA_KEYS_TYPE.put(METADATA_KEY_RDS_RT, METADATA_TYPE_TEXT);
METADATA_KEYS_TYPE.put(METADATA_KEY_TITLE, METADATA_TYPE_TEXT);
METADATA_KEYS_TYPE.put(METADATA_KEY_ARTIST, METADATA_TYPE_TEXT);
METADATA_KEYS_TYPE.put(METADATA_KEY_ALBUM, METADATA_TYPE_TEXT);
METADATA_KEYS_TYPE.put(METADATA_KEY_GENRE, METADATA_TYPE_TEXT);
METADATA_KEYS_TYPE.put(METADATA_KEY_ICON, METADATA_TYPE_BITMAP);
METADATA_KEYS_TYPE.put(METADATA_KEY_ART, METADATA_TYPE_BITMAP);
}
// keep in sync with: system/media/radio/include/system/radio_metadata.h
private static final int NATIVE_KEY_INVALID = -1;
private static final int NATIVE_KEY_RDS_PI = 0;
private static final int NATIVE_KEY_RDS_PS = 1;
private static final int NATIVE_KEY_RDS_PTY = 2;
private static final int NATIVE_KEY_RBDS_PTY = 3;
private static final int NATIVE_KEY_RDS_RT = 4;
private static final int NATIVE_KEY_TITLE = 5;
private static final int NATIVE_KEY_ARTIST = 6;
private static final int NATIVE_KEY_ALBUM = 7;
private static final int NATIVE_KEY_GENRE = 8;
private static final int NATIVE_KEY_ICON = 9;
private static final int NATIVE_KEY_ART = 10;
private static final SparseArray<String> NATIVE_KEY_MAPPING;
static {
NATIVE_KEY_MAPPING = new SparseArray<String>();
NATIVE_KEY_MAPPING.put(NATIVE_KEY_RDS_PI, METADATA_KEY_RDS_PI);
NATIVE_KEY_MAPPING.put(NATIVE_KEY_RDS_PS, METADATA_KEY_RDS_PS);
NATIVE_KEY_MAPPING.put(NATIVE_KEY_RDS_PTY, METADATA_KEY_RDS_PTY);
NATIVE_KEY_MAPPING.put(NATIVE_KEY_RBDS_PTY, METADATA_KEY_RBDS_PTY);
NATIVE_KEY_MAPPING.put(NATIVE_KEY_RDS_RT, METADATA_KEY_RDS_RT);
NATIVE_KEY_MAPPING.put(NATIVE_KEY_TITLE, METADATA_KEY_TITLE);
NATIVE_KEY_MAPPING.put(NATIVE_KEY_ARTIST, METADATA_KEY_ARTIST);
NATIVE_KEY_MAPPING.put(NATIVE_KEY_ALBUM, METADATA_KEY_ALBUM);
NATIVE_KEY_MAPPING.put(NATIVE_KEY_GENRE, METADATA_KEY_GENRE);
NATIVE_KEY_MAPPING.put(NATIVE_KEY_ICON, METADATA_KEY_ICON);
NATIVE_KEY_MAPPING.put(NATIVE_KEY_ART, METADATA_KEY_ART);
}
private final Bundle mBundle;
RadioMetadata() {
mBundle = new Bundle();
}
private RadioMetadata(Bundle bundle) {
mBundle = new Bundle(bundle);
}
private RadioMetadata(Parcel in) {
mBundle = in.readBundle();
}
/**
* Returns {@code true} if the given key is contained in the meta data
*
* @param key a String key
* @return {@code true} if the key exists in this meta data, {@code false} otherwise
*/
public boolean containsKey(String key) {
return mBundle.containsKey(key);
}
/**
* Returns the text value associated with the given key as a String, or null
* if the key is not found in the meta data.
*
* @param key The key the value is stored under
* @return a String value, or null
*/
public String getString(String key) {
return mBundle.getString(key);
}
/**
* Returns the value associated with the given key,
* or 0 if the key is not found in the meta data.
*
* @param key The key the value is stored under
* @return an int value
*/
public int getInt(String key) {
return mBundle.getInt(key, 0);
}
/**
* Returns a {@link Bitmap} for the given key or null if the key is not found in the meta data.
*
* @param key The key the value is stored under
* @return a {@link Bitmap} or null
*/
public Bitmap getBitmap(String key) {
Bitmap bmp = null;
try {
bmp = mBundle.getParcelable(key);
} catch (Exception e) {
// ignore, value was not a bitmap
Log.w(TAG, "Failed to retrieve a key as Bitmap.", e);
}
return bmp;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeBundle(mBundle);
}
/**
* Returns the number of fields in this meta data.
*
* @return the number of fields in the meta data.
*/
public int size() {
return mBundle.size();
}
/**
* Returns a Set containing the Strings used as keys in this meta data.
*
* @return a Set of String keys
*/
public Set<String> keySet() {
return mBundle.keySet();
}
/**
* Helper for getting the String key used by {@link RadioMetadata} from the
* corrsponding native integer key.
*
* @param editorKey The key used by the editor
* @return the key used by this class or null if no mapping exists
* @hide
*/
public static String getKeyFromNativeKey(int nativeKey) {
return NATIVE_KEY_MAPPING.get(nativeKey, null);
}
public static final Parcelable.Creator<RadioMetadata> CREATOR =
new Parcelable.Creator<RadioMetadata>() {
@Override
public RadioMetadata createFromParcel(Parcel in) {
return new RadioMetadata(in);
}
@Override
public RadioMetadata[] newArray(int size) {
return new RadioMetadata[size];
}
};
/**
* Use to build RadioMetadata objects.
*/
public static final class Builder {
private final Bundle mBundle;
/**
* Create an empty Builder. Any field that should be included in the
* {@link RadioMetadata} must be added.
*/
public Builder() {
mBundle = new Bundle();
}
/**
* Create a Builder using a {@link RadioMetadata} instance to set the
* initial values. All fields in the source meta data will be included in
* the new meta data. Fields can be overwritten by adding the same key.
*
* @param source
*/
public Builder(RadioMetadata source) {
mBundle = new Bundle(source.mBundle);
}
/**
* Create a Builder using a {@link RadioMetadata} instance to set
* initial values, but replace bitmaps with a scaled down copy if they
* are larger than maxBitmapSize.
*
* @param source The original meta data to copy.
* @param maxBitmapSize The maximum height/width for bitmaps contained
* in the meta data.
* @hide
*/
public Builder(RadioMetadata source, int maxBitmapSize) {
this(source);
for (String key : mBundle.keySet()) {
Object value = mBundle.get(key);
if (value != null && value instanceof Bitmap) {
Bitmap bmp = (Bitmap) value;
if (bmp.getHeight() > maxBitmapSize || bmp.getWidth() > maxBitmapSize) {
putBitmap(key, scaleBitmap(bmp, maxBitmapSize));
}
}
}
}
/**
* Put a String value into the meta data. Custom keys may be used, but if
* the METADATA_KEYs defined in this class are used they may only be one
* of the following:
* <ul>
* <li>{@link #METADATA_KEY_RDS_PI}</li>
* <li>{@link #METADATA_KEY_RDS_PS}</li>
* <li>{@link #METADATA_KEY_RDS_RT}</li>
* <li>{@link #METADATA_KEY_TITLE}</li>
* <li>{@link #METADATA_KEY_ARTIST}</li>
* <li>{@link #METADATA_KEY_ALBUM}</li>
* <li>{@link #METADATA_KEY_GENRE}</li>
* </ul>
*
* @param key The key for referencing this value
* @param value The String value to store
* @return the same Builder instance
*/
public Builder putString(String key, String value) {
if (!METADATA_KEYS_TYPE.containsKey(key) ||
METADATA_KEYS_TYPE.get(key) != METADATA_TYPE_TEXT) {
throw new IllegalArgumentException("The " + key
+ " key cannot be used to put a String");
}
mBundle.putString(key, value);
return this;
}
/**
* Put an int value into the meta data. Custom keys may be used, but if
* the METADATA_KEYs defined in this class are used they may only be one
* of the following:
* <ul>
* <li>{@link #METADATA_KEY_RDS_PTY}</li>
* <li>{@link #METADATA_KEY_RBDS_PTY}</li>
* </ul>
*
* @param key The key for referencing this value
* @param value The int value to store
* @return the same Builder instance
*/
public Builder putInt(String key, int value) {
if (!METADATA_KEYS_TYPE.containsKey(key) ||
METADATA_KEYS_TYPE.get(key) != METADATA_TYPE_INT) {
throw new IllegalArgumentException("The " + key
+ " key cannot be used to put a long");
}
mBundle.putInt(key, value);
return this;
}
/**
* Put a {@link Bitmap} into the meta data. Custom keys may be used, but
* if the METADATA_KEYs defined in this class are used they may only be
* one of the following:
* <ul>
* <li>{@link #METADATA_KEY_ICON}</li>
* <li>{@link #METADATA_KEY_ART}</li>
* </ul>
* <p>
*
* @param key The key for referencing this value
* @param value The Bitmap to store
* @return the same Builder instance
*/
public Builder putBitmap(String key, Bitmap value) {
if (!METADATA_KEYS_TYPE.containsKey(key) ||
METADATA_KEYS_TYPE.get(key) != METADATA_TYPE_BITMAP) {
throw new IllegalArgumentException("The " + key
+ " key cannot be used to put a Bitmap");
}
mBundle.putParcelable(key, value);
return this;
}
/**
* Creates a {@link RadioMetadata} instance with the specified fields.
*
* @return a new {@link RadioMetadata} object
*/
public RadioMetadata build() {
return new RadioMetadata(mBundle);
}
private Bitmap scaleBitmap(Bitmap bmp, int maxSize) {
float maxSizeF = maxSize;
float widthScale = maxSizeF / bmp.getWidth();
float heightScale = maxSizeF / bmp.getHeight();
float scale = Math.min(widthScale, heightScale);
int height = (int) (bmp.getHeight() * scale);
int width = (int) (bmp.getWidth() * scale);
return Bitmap.createScaledBitmap(bmp, width, height, true);
}
}
int putIntFromNative(int nativeKey, int value) {
String key = getKeyFromNativeKey(nativeKey);
if (!METADATA_KEYS_TYPE.containsKey(key) ||
METADATA_KEYS_TYPE.get(key) != METADATA_TYPE_INT) {
return -1;
}
mBundle.putInt(key, value);
return 0;
}
int putStringFromNative(int nativeKey, String value) {
String key = getKeyFromNativeKey(nativeKey);
if (!METADATA_KEYS_TYPE.containsKey(key) ||
METADATA_KEYS_TYPE.get(key) != METADATA_TYPE_TEXT) {
return -1;
}
mBundle.putString(key, value);
return 0;
}
int putBitmapFromNative(int nativeKey, byte[] value) {
String key = getKeyFromNativeKey(nativeKey);
if (!METADATA_KEYS_TYPE.containsKey(key) ||
METADATA_KEYS_TYPE.get(key) != METADATA_TYPE_BITMAP) {
return -1;
}
Bitmap bmp = null;
try {
bmp = BitmapFactory.decodeByteArray(value, 0, value.length);
} catch (Exception e) {
} finally {
if (bmp == null) {
return -1;
}
mBundle.putParcelable(key, bmp);
return 0;
}
}
}

218
core/java/android/hardware/radio/RadioModule.java Normal file
View File

@@ -0,0 +1,218 @@
/*
* Copyright (C) 2015 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 android.hardware.radio;
import android.annotation.SystemApi;
import android.content.Context;
import android.content.Intent;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import java.lang.ref.WeakReference;
import java.util.UUID;
/**
* A RadioModule implements the RadioTuner interface for a broadcast radio tuner physically
* present on the device and exposed by the radio HAL.
*
* @hide
*/
public class RadioModule extends RadioTuner {
private long mNativeContext = 0;
private int mId;
private NativeEventHandlerDelegate mEventHandlerDelegate;
RadioModule(int moduleId, RadioManager.BandConfig config, boolean withAudio,
RadioTuner.Callback callback, Handler handler) {
mId = moduleId;
mEventHandlerDelegate = new NativeEventHandlerDelegate(callback, handler);
native_setup(new WeakReference<RadioModule>(this), config, withAudio);
}
private native void native_setup(Object module_this,
RadioManager.BandConfig config, boolean withAudio);
@Override
protected void finalize() {
native_finalize();
}
private native void native_finalize();
boolean initCheck() {
return mNativeContext != 0;
}
// RadioTuner implementation
public native void close();
public native int setConfiguration(RadioManager.BandConfig config);
public native int getConfiguration(RadioManager.BandConfig[] config);
public native int setMute(boolean mute);
public native boolean getMute();
public native int step(int direction, boolean skipSubChannel);
public native int scan(int direction, boolean skipSubChannel);
public native int tune(int channel, int subChannel);
public native int cancel();
public native int getProgramInformation(RadioManager.ProgramInfo[] info);
public native boolean isAntennaConnected();
public native boolean hasControl();
/* keep in sync with radio_event_type_t in system/core/include/system/radio.h */
static final int EVENT_HW_FAILURE = 0;
static final int EVENT_CONFIG = 1;
static final int EVENT_ANTENNA = 2;
static final int EVENT_TUNED = 3;
static final int EVENT_METADATA = 4;
static final int EVENT_TA = 5;
static final int EVENT_AF_SWITCH = 6;
static final int EVENT_CONTROL = 100;
static final int EVENT_SERVER_DIED = 101;
private class NativeEventHandlerDelegate {
private final Handler mHandler;
NativeEventHandlerDelegate(final RadioTuner.Callback callback,
Handler handler) {
// find the looper for our new event handler
Looper looper;
if (handler != null) {
looper = handler.getLooper();
} else {
looper = Looper.getMainLooper();
}
// construct the event handler with this looper
if (looper != null) {
// implement the event handler delegate
mHandler = new Handler(looper) {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case EVENT_HW_FAILURE:
if (callback != null) {
callback.onError(RadioTuner.ERROR_HARDWARE_FAILURE);
}
break;
case EVENT_CONFIG: {
RadioManager.BandConfig config = (RadioManager.BandConfig)msg.obj;
switch(msg.arg1) {
case RadioManager.STATUS_OK:
if (callback != null) {
callback.onConfigurationChanged(config);
}
break;
default:
if (callback != null) {
callback.onError(RadioTuner.ERROR_CONFIG);
}
break;
}
} break;
case EVENT_ANTENNA:
if (callback != null) {
callback.onAntennaState(msg.arg2 == 1);
}
break;
case EVENT_AF_SWITCH:
case EVENT_TUNED: {
RadioManager.ProgramInfo info = (RadioManager.ProgramInfo)msg.obj;
switch (msg.arg1) {
case RadioManager.STATUS_OK:
if (callback != null) {
callback.onProgramInfoChanged(info);
}
break;
case RadioManager.STATUS_TIMED_OUT:
if (callback != null) {
callback.onError(RadioTuner.ERROR_SCAN_TIMEOUT);
}
break;
case RadioManager.STATUS_INVALID_OPERATION:
default:
if (callback != null) {
callback.onError(RadioTuner.ERROR_CANCELLED);
}
break;
}
} break;
case EVENT_METADATA: {
RadioMetadata metadata = (RadioMetadata)msg.obj;
if (callback != null) {
callback.onMetadataChanged(metadata);
}
} break;
case EVENT_TA:
if (callback != null) {
callback.onTrafficAnnouncement(msg.arg2 == 1);
}
break;
case EVENT_CONTROL:
if (callback != null) {
callback.onControlChanged(msg.arg2 == 1);
}
break;
case EVENT_SERVER_DIED:
if (callback != null) {
callback.onError(RadioTuner.ERROR_SERVER_DIED);
}
break;
default:
// Should not happen
break;
}
}
};
} else {
mHandler = null;
}
}
Handler handler() {
return mHandler;
}
}
@SuppressWarnings("unused")
private static void postEventFromNative(Object module_ref,
int what, int arg1, int arg2, Object obj) {
RadioModule module = (RadioModule)((WeakReference)module_ref).get();
if (module == null) {
return;
}
NativeEventHandlerDelegate delegate = module.mEventHandlerDelegate;
if (delegate != null) {
Handler handler = delegate.handler();
if (handler != null) {
Message m = handler.obtainMessage(what, arg1, arg2, obj);
handler.sendMessage(m);
}
}
}
}

302
core/java/android/hardware/radio/RadioTuner.java Normal file
View File

@@ -0,0 +1,302 @@
/*
* Copyright (C) 2015 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 android.hardware.radio;
import android.annotation.SystemApi;
import android.content.Context;
import android.content.Intent;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import java.lang.ref.WeakReference;
import java.util.UUID;
/**
* RadioTuner interface provides methods to control a radio tuner on the device: selecting and
* configuring the active band, muting/unmuting, scanning and tuning, etc...
*
* Obtain a RadioTuner interface by calling {@link RadioManager#openTuner(int,
* RadioManager.BandConfig, boolean, RadioTuner.Callback, Handler)}.
* @hide
*/
@SystemApi
public abstract class RadioTuner {
/** Scanning direction UP for {@link #step(int, boolean)}, {@link #scan(int, boolean)} */
public static final int DIRECTION_UP = 0;
/** Scanning directions DOWN for {@link #step(int, boolean)}, {@link #scan(int, boolean)} */
public static final int DIRECTION_DOWN = 1;
/**
* Close the tuner interface. The {@link Callback} callback will not be called
* anymore and associated resources will be released.
* Must be called when the tuner is not needed to make hardware resources available to others.
* */
public abstract void close();
/**
* Set the active band configuration for this module.
* Must be a valid configuration obtained via buildConfig() from a valid BandDescriptor listed
* in the ModuleProperties of the module with the specified ID.
* @param config The desired band configuration (FmBandConfig or AmBandConfig).
* @return
* <ul>
* <li>{@link RadioManager#STATUS_OK} in case of success, </li>
* <li>{@link RadioManager#STATUS_ERROR} in case of unspecified error, </li>
* <li>{@link RadioManager#STATUS_NO_INIT} if the native service cannot be reached, </li>
* <li>{@link RadioManager#STATUS_BAD_VALUE} if parameters are invalid, </li>
* <li>{@link RadioManager#STATUS_INVALID_OPERATION} if the call is out of sequence, </li>
* <li>{@link RadioManager#STATUS_DEAD_OBJECT} if the binder transaction to the native
* service fails, </li>
* </ul>
*/
public abstract int setConfiguration(RadioManager.BandConfig config);
/**
* Get current configuration.
* @param config a BandConfig array of lengh 1 where the configuration is returned.
* @return
* <ul>
* <li>{@link RadioManager#STATUS_OK} in case of success, </li>
* <li>{@link RadioManager#STATUS_ERROR} in case of unspecified error, </li>
* <li>{@link RadioManager#STATUS_NO_INIT} if the native service cannot be reached, </li>
* <li>{@link RadioManager#STATUS_BAD_VALUE} if parameters are invalid, </li>
* <li>{@link RadioManager#STATUS_INVALID_OPERATION} if the call is out of sequence, </li>
* <li>{@link RadioManager#STATUS_DEAD_OBJECT} if the binder transaction to the native
* service fails, </li>
* </ul>
*/
public abstract int getConfiguration(RadioManager.BandConfig[] config);
/**
* Set mute state. When muted, the radio tuner audio source is not available for playback on
* any audio device. when unmuted, the radio tuner audio source is output as a media source
* and renderd over the audio device selected for media use case.
* The radio tuner audio source is muted by default when the tuner is first attached.
* Only effective if the tuner is attached with audio enabled.
*
* @param mute the requested mute state.
* @return
* <ul>
* <li>{@link RadioManager#STATUS_OK} in case of success, </li>
* <li>{@link RadioManager#STATUS_ERROR} in case of unspecified error, </li>
* <li>{@link RadioManager#STATUS_NO_INIT} if the native service cannot be reached, </li>
* <li>{@link RadioManager#STATUS_INVALID_OPERATION} if the call is out of sequence, </li>
* <li>{@link RadioManager#STATUS_DEAD_OBJECT} if the binder transaction to the native
* service fails, </li>
* </ul>
*/
public abstract int setMute(boolean mute);
/**
* Get mute state.
*
* @return {@code true} if the radio tuner audio source is muted or a problem occured
* retrieving the mute state, {@code false} otherwise.
*/
public abstract boolean getMute();
/**
* Step up or down by one channel spacing.
* The operation is asynchronous and {@link Callback}
* onProgramInfoChanged() will be called when step completes or
* onError() when cancelled or timeout.
* @param direction {@link #DIRECTION_UP} or {@link #DIRECTION_DOWN}.
* @param skipSubChannel indicates to skip sub channels when the configuration currently
* selected supports sub channel (e.g HD Radio). N/A otherwise.
* @return
* <ul>
* <li>{@link RadioManager#STATUS_OK} in case of success, </li>
* <li>{@link RadioManager#STATUS_ERROR} in case of unspecified error, </li>
* <li>{@link RadioManager#STATUS_NO_INIT} if the native service cannot be reached, </li>
* <li>{@link RadioManager#STATUS_BAD_VALUE} if parameters are invalid, </li>
* <li>{@link RadioManager#STATUS_INVALID_OPERATION} if the call is out of sequence, </li>
* <li>{@link RadioManager#STATUS_DEAD_OBJECT} if the binder transaction to the native
* service fails, </li>
* </ul>
*/
public abstract int step(int direction, boolean skipSubChannel);
/**
* Scan up or down to next valid station.
* The operation is asynchronous and {@link Callback}
* onProgramInfoChanged() will be called when scan completes or
* onError() when cancelled or timeout.
* @param direction {@link #DIRECTION_UP} or {@link #DIRECTION_DOWN}.
* @param skipSubChannel indicates to skip sub channels when the configuration currently
* selected supports sub channel (e.g HD Radio). N/A otherwise.
* @return
* <ul>
* <li>{@link RadioManager#STATUS_OK} in case of success, </li>
* <li>{@link RadioManager#STATUS_ERROR} in case of unspecified error, </li>
* <li>{@link RadioManager#STATUS_NO_INIT} if the native service cannot be reached, </li>
* <li>{@link RadioManager#STATUS_BAD_VALUE} if parameters are invalid, </li>
* <li>{@link RadioManager#STATUS_INVALID_OPERATION} if the call is out of sequence, </li>
* <li>{@link RadioManager#STATUS_DEAD_OBJECT} if the binder transaction to the native
* service fails, </li>
* </ul>
*/
public abstract int scan(int direction, boolean skipSubChannel);
/**
* Tune to a specific frequency.
* The operation is asynchronous and {@link Callback}
* onProgramInfoChanged() will be called when tune completes or
* onError() when cancelled or timeout.
* @param channel the specific channel or frequency to tune to.
* @param subChannel the specific sub-channel to tune to. N/A if the selected configuration
* does not support cub channels.
* @return
* <ul>
* <li>{@link RadioManager#STATUS_OK} in case of success, </li>
* <li>{@link RadioManager#STATUS_ERROR} in case of unspecified error, </li>
* <li>{@link RadioManager#STATUS_NO_INIT} if the native service cannot be reached, </li>
* <li>{@link RadioManager#STATUS_BAD_VALUE} if parameters are invalid, </li>
* <li>{@link RadioManager#STATUS_INVALID_OPERATION} if the call is out of sequence, </li>
* <li>{@link RadioManager#STATUS_DEAD_OBJECT} if the binder transaction to the native
* service fails, </li>
* </ul>
*/
public abstract int tune(int channel, int subChannel);
/**
* Cancel a pending scan or tune operation.
* If an operation is pending, {@link Callback} onError() will be called with
* {@link #ERROR_CANCELLED}.
* @return
* <ul>
* <li>{@link RadioManager#STATUS_OK} in case of success, </li>
* <li>{@link RadioManager#STATUS_ERROR} in case of unspecified error, </li>
* <li>{@link RadioManager#STATUS_NO_INIT} if the native service cannot be reached, </li>
* <li>{@link RadioManager#STATUS_BAD_VALUE} if parameters are invalid, </li>
* <li>{@link RadioManager#STATUS_INVALID_OPERATION} if the call is out of sequence, </li>
* <li>{@link RadioManager#STATUS_DEAD_OBJECT} if the binder transaction to the native
* service fails, </li>
* </ul>
*/
public abstract int cancel();
/**
* Get current station information.
* @param info a ProgramInfo array of lengh 1 where the information is returned.
* @return
* <ul>
* <li>{@link RadioManager#STATUS_OK} in case of success, </li>
* <li>{@link RadioManager#STATUS_ERROR} in case of unspecified error, </li>
* <li>{@link RadioManager#STATUS_NO_INIT} if the native service cannot be reached, </li>
* <li>{@link RadioManager#STATUS_BAD_VALUE} if parameters are invalid, </li>
* <li>{@link RadioManager#STATUS_INVALID_OPERATION} if the call is out of sequence, </li>
* <li>{@link RadioManager#STATUS_DEAD_OBJECT} if the binder transaction to the native
* service fails, </li>
* </ul>
*/
public abstract int getProgramInformation(RadioManager.ProgramInfo[] info);
/**
* Get current antenna connection state for current configuration.
* Only valid if a configuration has been applied.
* @return {@code true} if the antenna is connected, {@code false} otherwise.
*/
public abstract boolean isAntennaConnected();
/**
* Indicates if this client actually controls the tuner.
* Control is always granted after
* {@link RadioManager#openTuner(int,
* RadioManager.BandConfig, boolean, Callback, Handler)}
* returns a non null tuner interface.
* Control is lost when another client opens an interface on the same tuner.
* When this happens, {@link Callback#onControlChanged(boolean)} is received.
* The client can either wait for control to be returned (which is indicated by the same
* callback) or close and reopen the tuner interface.
* @return {@code true} if this interface controls the tuner,
* {@code false} otherwise or if a problem occured retrieving the state.
*/
public abstract boolean hasControl();
/** Indicates a failure of radio IC or driver.
* The application must close and re open the tuner */
public static final int ERROR_HARDWARE_FAILURE = 0;
/** Indicates a failure of the radio service.
* The application must close and re open the tuner */
public static final int ERROR_SERVER_DIED = 1;
/** A pending seek or tune operation was cancelled */
public static final int ERROR_CANCELLED = 2;
/** A pending seek or tune operation timed out */
public static final int ERROR_SCAN_TIMEOUT = 3;
/** The requested configuration could not be applied */
public static final int ERROR_CONFIG = 4;
/**
* Callback provided by the client application when opening a {@link RadioTuner}
* to receive asynchronous operation results, updates and error notifications.
*/
public static abstract class Callback {
/**
* onError() is called when an error occured while performing an asynchronous
* operation of when the hardware or system service experiences a problem.
* status is one of {@link #ERROR_HARDWARE_FAILURE}, {@link #ERROR_SERVER_DIED},
* {@link #ERROR_CANCELLED}, {@link #ERROR_SCAN_TIMEOUT},
* {@link #ERROR_CONFIG}
*/
public void onError(int status) {}
/**
* onConfigurationChanged() is called upon successful completion of
* {@link RadioManager#openTuner(int, RadioManager.BandConfig, boolean, Callback, Handler)}
* or {@link RadioTuner#setConfiguration(RadioManager.BandConfig)}
*/
public void onConfigurationChanged(RadioManager.BandConfig config) {}
/**
* onProgramInfoChanged() is called upon successful completion of
* {@link RadioTuner#step(int, boolean)}, {@link RadioTuner#scan(int, boolean)},
* {@link RadioTuner#tune(int, int)} or when a switching to alternate frequency occurs.
* Note that if metadata only are updated, {@link #onMetadataChanged(RadioMetadata)} will
* be called.
*/
public void onProgramInfoChanged(RadioManager.ProgramInfo info) {}
/**
* onMetadataChanged() is called when new meta data are received on current program.
* Meta data are also received in {@link RadioManager.ProgramInfo} when
* {@link #onProgramInfoChanged(RadioManager.ProgramInfo)} is called.
*/
public void onMetadataChanged(RadioMetadata metadata) {}
/**
* onTrafficAnnouncement() is called when a traffic announcement starts and stops.
*/
public void onTrafficAnnouncement(boolean active) {}
/**
* onAntennaState() is called when the antenna is connected or disconnected.
*/
public void onAntennaState(boolean connected) {}
/**
* onControlChanged() is called when the client loses or gains control of the radio tuner.
* The control is always granted after a successful call to
* {@link RadioManager#openTuner(int, RadioManager.BandConfig, boolean, Callback, Handler)}.
* If another client opens the same tuner, onControlChanged() will be called with
* control set to {@code false} to indicate loss of control.
* At this point, RadioTuner APIs other than getters will return
* {@link RadioManager#STATUS_INVALID_OPERATION}.
* When the other client releases the tuner, onControlChanged() will be called
* with control set to {@code true}.
*/
public void onControlChanged(boolean control) {}
}
}