() {
@Override
public void accept(Translator translator) {
if (translator == null) {
final long token = Binder.clearCallingIdentity();
try {
executor.execute(() -> callback.accept(null));
} finally {
Binder.restoreCallingIdentity(token);
}
return;
}
synchronized (mLock) {
mTranslators.put(tId, translator);
mTranslatorIds.put(translationContext, tId);
}
final long token = Binder.clearCallingIdentity();
try {
executor.execute(() -> callback.accept(translator));
} finally {
Binder.restoreCallingIdentity(token);
}
}
});
}
}
/**
* Creates an on-device Translator for natural language translation.
*
* NOTE: Call on a worker thread.
*
* @removed use {@link #createOnDeviceTranslator(TranslationContext, Executor, Consumer)}
* instead.
*
* @param translationContext {@link TranslationContext} containing the specs for creating the
* Translator.
*/
@Deprecated
@Nullable
@WorkerThread
public Translator createOnDeviceTranslator(@NonNull TranslationContext translationContext) {
Objects.requireNonNull(translationContext, "translationContext cannot be null");
synchronized (mLock) {
// TODO(b/176464808): Disallow multiple Translator now, it will throw
// IllegalStateException. Need to discuss if we can allow multiple Translators.
if (mTranslatorIds.containsKey(translationContext)) {
return mTranslators.get(mTranslatorIds.get(translationContext));
}
int translatorId;
do {
translatorId = Math.abs(ID_GENERATOR.nextInt());
} while (translatorId == 0 || mTranslators.indexOfKey(translatorId) >= 0);
final Translator newTranslator = new Translator(mContext, translationContext,
translatorId, this, mHandler, mService);
// Start the Translator session and wait for the result
newTranslator.start();
try {
if (!newTranslator.isSessionCreated()) {
return null;
}
mTranslators.put(translatorId, newTranslator);
mTranslatorIds.put(translationContext, translatorId);
return newTranslator;
} catch (Translator.ServiceBinderReceiver.TimeoutException e) {
// TODO(b/176464808): maybe make SyncResultReceiver.TimeoutException constructor
// public and use it.
Log.e(TAG, "Timed out getting create session: " + e);
return null;
}
}
}
/** @removed Use {@link #createOnDeviceTranslator(TranslationContext)} */
@Deprecated
@Nullable
@WorkerThread
public Translator createTranslator(@NonNull TranslationContext translationContext) {
return createOnDeviceTranslator(translationContext);
}
/**
* Returns a set of {@link TranslationCapability}s describing the capabilities for on-device
* {@link Translator}s.
*
*
These translation capabilities contains a source and target {@link TranslationSpec}
* representing the data expected for both ends of translation process. The capabilities
* provides the information and limitations for generating a {@link TranslationContext}.
* The context object can then be used by
* {@link #createOnDeviceTranslator(TranslationContext, Executor, Consumer)} to obtain a
* {@link Translator} for translations.
*
* NOTE: Call on a worker thread.
*
* @param sourceFormat data format for the input data to be translated.
* @param targetFormat data format for the expected translated output data.
* @return A set of {@link TranslationCapability}s.
*/
@NonNull
@WorkerThread
public Set getOnDeviceTranslationCapabilities(
@TranslationSpec.DataFormat int sourceFormat,
@TranslationSpec.DataFormat int targetFormat) {
try {
final SynchronousResultReceiver receiver = new SynchronousResultReceiver();
mService.onTranslationCapabilitiesRequest(sourceFormat, targetFormat, receiver,
mContext.getUserId());
final SynchronousResultReceiver.Result result =
receiver.awaitResult(SYNC_CALLS_TIMEOUT_MS);
if (result.resultCode != STATUS_SYNC_CALL_SUCCESS) {
return Collections.emptySet();
}
Parcelable[] parcelables = result.bundle.getParcelableArray(EXTRA_CAPABILITIES);
ArraySet capabilities = new ArraySet();
for (Parcelable obj : parcelables) {
if (obj instanceof TranslationCapability) {
capabilities.add((TranslationCapability) obj);
}
}
return capabilities;
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
} catch (TimeoutException e) {
Log.e(TAG, "Timed out getting supported translation capabilities: " + e);
return Collections.emptySet();
}
}
/** @removed Use {@link #getOnDeviceTranslationCapabilities(int, int)} */
@Deprecated
@NonNull
@WorkerThread
public Set getTranslationCapabilities(
@TranslationSpec.DataFormat int sourceFormat,
@TranslationSpec.DataFormat int targetFormat) {
return getOnDeviceTranslationCapabilities(sourceFormat, targetFormat);
}
/**
* Adds a {@link TranslationCapability} Consumer to listen for updates on states of on-device
* {@link TranslationCapability}s.
*
* @param capabilityListener a {@link TranslationCapability} Consumer to receive the updated
* {@link TranslationCapability} from the on-device translation service.
*/
public void addOnDeviceTranslationCapabilityUpdateListener(
@NonNull @CallbackExecutor Executor executor,
@NonNull Consumer capabilityListener) {
Objects.requireNonNull(executor, "executor should not be null");
Objects.requireNonNull(capabilityListener, "capability listener should not be null");
synchronized (mLock) {
if (mCapabilityCallbacks.containsKey(capabilityListener)) {
Log.w(TAG, "addOnDeviceTranslationCapabilityUpdateListener: the listener for "
+ capabilityListener + " already registered; ignoring.");
return;
}
final IRemoteCallback remoteCallback = new TranslationCapabilityRemoteCallback(executor,
capabilityListener);
try {
mService.registerTranslationCapabilityCallback(remoteCallback,
mContext.getUserId());
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
mCapabilityCallbacks.put(capabilityListener, remoteCallback);
}
}
/**
* @removed Use {@link TranslationManager#addOnDeviceTranslationCapabilityUpdateListener(
* java.util.concurrent.Executor, java.util.function.Consumer)}
*/
@Deprecated
public void addOnDeviceTranslationCapabilityUpdateListener(
@TranslationSpec.DataFormat int sourceFormat,
@TranslationSpec.DataFormat int targetFormat,
@NonNull PendingIntent pendingIntent) {
Objects.requireNonNull(pendingIntent, "pending intent should not be null");
synchronized (mLock) {
final Pair formatPair = new Pair<>(sourceFormat, targetFormat);
mTranslationCapabilityUpdateListeners.computeIfAbsent(formatPair,
(formats) -> new ArrayList<>()).add(pendingIntent);
}
}
/**
* @removed Use {@link TranslationManager#addOnDeviceTranslationCapabilityUpdateListener(
* java.util.concurrent.Executor, java.util.function.Consumer)}
*/
@Deprecated
public void addTranslationCapabilityUpdateListener(
@TranslationSpec.DataFormat int sourceFormat,
@TranslationSpec.DataFormat int targetFormat,
@NonNull PendingIntent pendingIntent) {
addOnDeviceTranslationCapabilityUpdateListener(sourceFormat, targetFormat, pendingIntent);
}
/**
* Removes a {@link TranslationCapability} Consumer to listen for updates on states of
* on-device {@link TranslationCapability}s.
*
* @param capabilityListener the {@link TranslationCapability} Consumer to unregister
*/
public void removeOnDeviceTranslationCapabilityUpdateListener(
@NonNull Consumer capabilityListener) {
Objects.requireNonNull(capabilityListener, "capability callback should not be null");
synchronized (mLock) {
final IRemoteCallback remoteCallback = mCapabilityCallbacks.get(capabilityListener);
if (remoteCallback == null) {
Log.w(TAG, "removeOnDeviceTranslationCapabilityUpdateListener: the capability "
+ "listener not found; ignoring.");
return;
}
try {
mService.unregisterTranslationCapabilityCallback(remoteCallback,
mContext.getUserId());
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
mCapabilityCallbacks.remove(capabilityListener);
}
}
/**
* @removed Use {@link #removeOnDeviceTranslationCapabilityUpdateListener(
* java.util.function.Consumer)}.
*/
@Deprecated
public void removeOnDeviceTranslationCapabilityUpdateListener(
@TranslationSpec.DataFormat int sourceFormat,
@TranslationSpec.DataFormat int targetFormat,
@NonNull PendingIntent pendingIntent) {
Objects.requireNonNull(pendingIntent, "pending intent should not be null");
synchronized (mLock) {
final Pair formatPair = new Pair<>(sourceFormat, targetFormat);
if (mTranslationCapabilityUpdateListeners.containsKey(formatPair)) {
final ArrayList intents =
mTranslationCapabilityUpdateListeners.get(formatPair);
if (intents.contains(pendingIntent)) {
intents.remove(pendingIntent);
} else {
Log.w(TAG, "pending intent=" + pendingIntent + " does not exist in "
+ "mTranslationCapabilityUpdateListeners");
}
} else {
Log.w(TAG, "format pair=" + formatPair + " does not exist in "
+ "mTranslationCapabilityUpdateListeners");
}
}
}
/**
* @removed Use {@link #removeOnDeviceTranslationCapabilityUpdateListener(
* java.util.function.Consumer)}.
*/
@Deprecated
public void removeTranslationCapabilityUpdateListener(
@TranslationSpec.DataFormat int sourceFormat,
@TranslationSpec.DataFormat int targetFormat,
@NonNull PendingIntent pendingIntent) {
removeOnDeviceTranslationCapabilityUpdateListener(
sourceFormat, targetFormat, pendingIntent);
}
/**
* Returns an immutable PendingIntent which can be used to launch an activity to view/edit
* on-device translation settings.
*
* @return An immutable PendingIntent or {@code null} if one of reason met:
*
* - Device manufacturer (OEM) does not provide TranslationService.
* - The TranslationService doesn't provide the Settings.
*
**/
@Nullable
public PendingIntent getOnDeviceTranslationSettingsActivityIntent() {
final SyncResultReceiver resultReceiver = new SyncResultReceiver(SYNC_CALLS_TIMEOUT_MS);
try {
mService.getServiceSettingsActivity(resultReceiver, mContext.getUserId());
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
try {
return resultReceiver.getParcelableResult();
} catch (SyncResultReceiver.TimeoutException e) {
Log.e(TAG, "Fail to get translation service settings activity.");
return null;
}
}
/** @removed Use {@link #getOnDeviceTranslationSettingsActivityIntent()} */
@Deprecated
@Nullable
public PendingIntent getTranslationSettingsActivityIntent() {
return getOnDeviceTranslationSettingsActivityIntent();
}
void removeTranslator(int id) {
synchronized (mLock) {
mTranslators.remove(id);
for (int i = 0; i < mTranslatorIds.size(); i++) {
if (mTranslatorIds.valueAt(i) == id) {
mTranslatorIds.removeAt(i);
break;
}
}
}
}
AtomicInteger getAvailableRequestId() {
synchronized (mLock) {
return sAvailableRequestId;
}
}
private static class TranslationCapabilityRemoteCallback extends
IRemoteCallback.Stub {
private final Executor mExecutor;
private final Consumer mListener;
TranslationCapabilityRemoteCallback(Executor executor,
Consumer listener) {
mExecutor = executor;
mListener = listener;
}
@Override
public void sendResult(Bundle bundle) {
Binder.withCleanCallingIdentity(
() -> mExecutor.execute(() -> onTranslationCapabilityUpdate(bundle)));
}
private void onTranslationCapabilityUpdate(Bundle bundle) {
TranslationCapability capability =
(TranslationCapability) bundle.getParcelable(EXTRA_CAPABILITIES);
mListener.accept(capability);
}
}
}