xref: /aosp12/system/tools/aidl/tests/java/src/android/aidl/service/TestServiceServer.java

/*
 * Copyright (C) 2021, 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.aidl.service;

import android.aidl.tests.BackendType;
import android.aidl.tests.ByteEnum;
import android.aidl.tests.ConstantExpressionEnum;
import android.aidl.tests.GenericStructuredParcelable;
import android.aidl.tests.ICppJavaTests;
import android.aidl.tests.INamedCallback;
import android.aidl.tests.INewName;
import android.aidl.tests.IOldName;
import android.aidl.tests.ITestService;
import android.aidl.tests.IntEnum;
import android.aidl.tests.LongEnum;
import android.aidl.tests.SimpleParcelable;
import android.aidl.tests.StructuredParcelable;
import android.aidl.tests.Union;
import android.aidl.tests.extension.ExtendableParcelable;
import android.aidl.tests.extension.MyExt;
import android.aidl.versioned.tests.BazUnion;
import android.aidl.versioned.tests.Foo;
import android.aidl.versioned.tests.IFooInterface;
import android.os.Binder;
import android.os.IBinder;
import android.os.Parcel;
import android.os.ParcelFileDescriptor;
import android.os.PersistableBundle;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.ServiceSpecificException;
import android.util.Log;
import java.io.FileDescriptor;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class TestServiceServer extends ITestService.Stub {
  public static void main(String[] args) {
    TestServiceServer myServer = new TestServiceServer();
    ServiceManager.addService(ITestService.class.getName(), myServer);

    FooInterface foo = new FooInterface();
    ServiceManager.addService(IFooInterface.class.getName(), foo);

    Binder.joinThreadPool();
  }

  private static class FooInterface extends IFooInterface.Stub {
    @Override
    public void originalApi() {}
    @Override
    public String acceptUnionAndReturnString(BazUnion b) {
      if (b.getTag() == BazUnion.intNum) {
        return "" + b.getIntNum();
      }
      throw new IllegalArgumentException();
    }
    @Override
    public int returnsLengthOfFooArray(Foo[] foos) {
      return foos.length;
    }
    @Override
    public int ignoreParcelablesAndRepeatInt(Foo inFoo, Foo inoutFoo, Foo outFoo, int value) {
      return value;
    }
    @Override
    public final int getInterfaceVersion() {
      return IFooInterface.VERSION;
    }
    @Override
    public final String getInterfaceHash() {
      return IFooInterface.HASH;
    }
  }

  @Override
  public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
    // UnimplementedMethod
    if (code == 1)
      return false;
    return super.onTransact(code, data, reply, flags);
  }

  @Override
  public int UnimplementedMethod(int arg) throws RemoteException {
    throw new UnsupportedOperationException();
  }
  @Override
  public void TestOneway() throws RemoteException {
    throw new RemoteException();
  }
  @Override
  public void Deprecated() throws RemoteException {}
  @Override
  public boolean RepeatBoolean(boolean token) throws RemoteException {
    return token;
  }
  @Override
  public byte RepeatByte(byte token) throws RemoteException {
    return token;
  }
  @Override
  public char RepeatChar(char token) throws RemoteException {
    return token;
  }
  @Override
  public int RepeatInt(int token) throws RemoteException {
    return token;
  }
  @Override
  public long RepeatLong(long token) throws RemoteException {
    return token;
  }
  @Override
  public float RepeatFloat(float token) throws RemoteException {
    return token;
  }
  @Override
  public double RepeatDouble(double token) throws RemoteException {
    return token;
  }
  @Override
  public String RepeatString(String token) throws RemoteException {
    return token;
  }
  @Override
  public byte RepeatByteEnum(byte token) throws RemoteException {
    return token;
  }
  @Override
  public int RepeatIntEnum(int token) throws RemoteException {
    return token;
  }
  @Override
  public long RepeatLongEnum(long token) throws RemoteException {
    return token;
  }
  @Override
  public boolean[] ReverseBoolean(boolean[] input, boolean[] repeated) throws RemoteException {
    boolean[] reversed = new boolean[input.length];
    for (int i = 0; i < input.length; i++) {
      repeated[i] = input[i];
      reversed[i] = input[input.length - i - 1];
    }
    return reversed;
  }
  @Override
  public byte[] ReverseByte(byte[] input, byte[] repeated) throws RemoteException {
    byte[] reversed = new byte[input.length];
    for (int i = 0; i < input.length; i++) {
      repeated[i] = input[i];
      reversed[i] = input[input.length - i - 1];
    }
    return reversed;
  }
  @Override
  public char[] ReverseChar(char[] input, char[] repeated) throws RemoteException {
    char[] reversed = new char[input.length];
    for (int i = 0; i < input.length; i++) {
      repeated[i] = input[i];
      reversed[i] = input[input.length - i - 1];
    }
    return reversed;
  }
  @Override
  public int[] ReverseInt(int[] input, int[] repeated) throws RemoteException {
    int[] reversed = new int[input.length];
    for (int i = 0; i < input.length; i++) {
      repeated[i] = input[i];
      reversed[i] = input[input.length - i - 1];
    }
    return reversed;
  }
  @Override
  public long[] ReverseLong(long[] input, long[] repeated) throws RemoteException {
    long[] reversed = new long[input.length];
    for (int i = 0; i < input.length; i++) {
      repeated[i] = input[i];
      reversed[i] = input[input.length - i - 1];
    }
    return reversed;
  }
  @Override
  public float[] ReverseFloat(float[] input, float[] repeated) throws RemoteException {
    float[] reversed = new float[input.length];
    for (int i = 0; i < input.length; i++) {
      repeated[i] = input[i];
      reversed[i] = input[input.length - i - 1];
    }
    return reversed;
  }
  @Override
  public double[] ReverseDouble(double[] input, double[] repeated) throws RemoteException {
    double[] reversed = new double[input.length];
    for (int i = 0; i < input.length; i++) {
      repeated[i] = input[i];
      reversed[i] = input[input.length - i - 1];
    }
    return reversed;
  }
  @Override
  public String[] ReverseString(String[] input, String[] repeated) throws RemoteException {
    String[] reversed = new String[input.length];
    for (int i = 0; i < input.length; i++) {
      repeated[i] = input[i];
      reversed[i] = input[input.length - i - 1];
    }
    return reversed;
  }
  @Override
  public byte[] ReverseByteEnum(byte[] input, byte[] repeated) throws RemoteException {
    byte[] reversed = new byte[input.length];
    for (int i = 0; i < input.length; i++) {
      repeated[i] = input[i];
      reversed[i] = input[input.length - i - 1];
    }
    return reversed;
  }
  @Override
  public int[] ReverseIntEnum(int[] input, int[] repeated) throws RemoteException {
    int[] reversed = new int[input.length];
    for (int i = 0; i < input.length; i++) {
      repeated[i] = input[i];
      reversed[i] = input[input.length - i - 1];
    }
    return reversed;
  }
  @Override
  public long[] ReverseLongEnum(long[] input, long[] repeated) throws RemoteException {
    long[] reversed = new long[input.length];
    for (int i = 0; i < input.length; i++) {
      repeated[i] = input[i];
      reversed[i] = input[input.length - i - 1];
    }
    return reversed;
  }

  private static class MyNamedCallback extends INamedCallback.Stub {
    public MyNamedCallback(String name) { mName = name; }
    @Override
    public String GetName() {
      return mName;
    }
    private String mName;
  }

  private HashMap<String, MyNamedCallback> mNamedCallbacks = new HashMap<>();

  @Override
  public INamedCallback GetOtherTestService(String name) throws RemoteException {
    if (!mNamedCallbacks.containsKey(name)) {
      mNamedCallbacks.put(name, new MyNamedCallback(name));
    }
    return mNamedCallbacks.get(name);
  }
  @Override
  public boolean VerifyName(INamedCallback service, String name) throws RemoteException {
    return name.equals(service.GetName());
  }
  @Override
  public List<String> ReverseStringList(List<String> input, List<String> repeated)
      throws RemoteException {
    ArrayList<String> reversed = new ArrayList<String>();
    for (String a : input) {
      repeated.add(a);
      reversed.add(0, a);
    }
    return reversed;
  }
  @Override
  public ParcelFileDescriptor RepeatParcelFileDescriptor(ParcelFileDescriptor read)
      throws RemoteException {
    return read;
  }
  @Override
  public ParcelFileDescriptor[] ReverseParcelFileDescriptorArray(
      ParcelFileDescriptor[] input, ParcelFileDescriptor[] repeated) throws RemoteException {
    ParcelFileDescriptor[] reversed = new ParcelFileDescriptor[input.length];
    for (int i = 0; i < input.length; i++) {
      repeated[i] = input[i];
      try {
        // extra dup, because of PARCELABLE_WRITE_RETURN_VALUE
        reversed[i] = input[input.length - i - 1].dup();
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    }
    return reversed;
  }
  @Override
  public void ThrowServiceException(int code) throws RemoteException {
    Log.i("TestServiceServer", "Throwing service specific exception " + code);
    throw new ServiceSpecificException(code);
  }
  @Override
  public int[] RepeatNullableIntArray(int[] input) throws RemoteException {
    return input;
  }
  @Override
  public byte[] RepeatNullableByteEnumArray(byte[] input) throws RemoteException {
    return input;
  }
  @Override
  public int[] RepeatNullableIntEnumArray(int[] input) throws RemoteException {
    return input;
  }
  @Override
  public long[] RepeatNullableLongEnumArray(long[] input) throws RemoteException {
    return input;
  }
  @Override
  public String RepeatNullableString(String input) throws RemoteException {
    return input;
  }
  @Override
  public List<String> RepeatNullableStringList(List<String> input) throws RemoteException {
    return input;
  }
  @Override
  public StructuredParcelable RepeatNullableParcelable(StructuredParcelable input)
      throws RemoteException {
    return input;
  }
  @Override
  public void TakesAnIBinder(IBinder input) throws RemoteException {
    // do nothing
  }
  @Override
  public void TakesANullableIBinder(IBinder input) throws RemoteException {
    // do nothing
  }
  @Override
  public String RepeatUtf8CppString(String token) throws RemoteException {
    return token;
  }
  @Override
  public String RepeatNullableUtf8CppString(String token) throws RemoteException {
    return token;
  }
  @Override
  public String[] ReverseUtf8CppString(String[] input, String[] repeated) throws RemoteException {
    String[] reversed = new String[input.length];
    for (int i = 0; i < input.length; i++) {
      repeated[i] = input[i];
      reversed[i] = input[input.length - i - 1];
    }
    return reversed;
  }
  @Override
  public String[] ReverseNullableUtf8CppString(String[] input, String[] repeated)
      throws RemoteException {
    if (input == null)
      return null;

    String[] reversed = new String[input.length];
    for (int i = 0; i < input.length; i++) {
      repeated[i] = input[i];
      reversed[i] = input[input.length - i - 1];
    }
    return reversed;
  }
  @Override
  public List<String> ReverseUtf8CppStringList(List<String> input, List<String> repeated)
      throws RemoteException {
    // note - cannot clear 'repeated' here, we can only change its length
    if (input == null)
      return null;

    ArrayList<String> reversed = new ArrayList<String>();
    for (String a : input) {
      repeated.add(a);
      reversed.add(0, a);
    }
    return reversed;
  }
  @Override
  public INamedCallback GetCallback(boolean return_null) throws RemoteException {
    if (return_null)
      return null;
    return new MyNamedCallback("a callback named GetCallback");
  }
  @Override
  public void FillOutStructuredParcelable(StructuredParcelable parcelable) throws RemoteException {
    parcelable.shouldBeJerry = "Jerry";
    parcelable.shouldContainThreeFs = new int[] {parcelable.f, parcelable.f, parcelable.f};
    parcelable.shouldBeByteBar = ByteEnum.BAR;
    parcelable.shouldBeIntBar = IntEnum.BAR;
    parcelable.shouldBeLongBar = LongEnum.BAR;
    parcelable.shouldContainTwoByteFoos = new byte[] {ByteEnum.FOO, ByteEnum.FOO};
    parcelable.shouldContainTwoIntFoos = new int[] {IntEnum.FOO, IntEnum.FOO};
    parcelable.shouldContainTwoLongFoos = new long[] {LongEnum.FOO, LongEnum.FOO};

    parcelable.const_exprs_1 = ConstantExpressionEnum.decInt32_1;
    parcelable.const_exprs_2 = ConstantExpressionEnum.decInt32_2;
    parcelable.const_exprs_3 = ConstantExpressionEnum.decInt64_1;
    parcelable.const_exprs_4 = ConstantExpressionEnum.decInt64_2;
    parcelable.const_exprs_5 = ConstantExpressionEnum.decInt64_3;
    parcelable.const_exprs_6 = ConstantExpressionEnum.decInt64_4;
    parcelable.const_exprs_7 = ConstantExpressionEnum.hexInt32_1;
    parcelable.const_exprs_8 = ConstantExpressionEnum.hexInt32_2;
    parcelable.const_exprs_9 = ConstantExpressionEnum.hexInt32_3;
    parcelable.const_exprs_10 = ConstantExpressionEnum.hexInt64_1;

    parcelable.shouldSetBit0AndBit2 = StructuredParcelable.BIT0 | StructuredParcelable.BIT2;

    parcelable.u = Union.ns(new int[] {1, 2, 3});
    parcelable.shouldBeConstS1 = Union.s(Union.S1);
  }

  private static class MyOldName extends IOldName.Stub {
    @Override
    public String RealName() {
      return "OldName";
    }
  }

  @Override
  public IOldName GetOldNameInterface() throws RemoteException {
    return new MyOldName();
  }

  private static class MyNewName extends INewName.Stub {
    @Override
    public String RealName() {
      return "NewName";
    }
  }

  @Override
  public INewName GetNewNameInterface() throws RemoteException {
    return new MyNewName();
  }

  class MyCppJavaTests extends ICppJavaTests.Stub {
    @Override
    public SimpleParcelable RepeatSimpleParcelable(SimpleParcelable input, SimpleParcelable repeat)
        throws RemoteException {
      repeat.set(input.getName(), input.getNumber());
      return input;
    }
    @Override
    public GenericStructuredParcelable<Integer, StructuredParcelable, Integer>
    RepeatGenericParcelable(
        GenericStructuredParcelable<Integer, StructuredParcelable, Integer> input,
        GenericStructuredParcelable<Integer, StructuredParcelable, Integer> repeat)
        throws RemoteException {
      repeat.a = input.a;
      repeat.b = input.b;
      return input;
    }
    @Override
    public PersistableBundle RepeatPersistableBundle(PersistableBundle input)
        throws RemoteException {
      return input;
    }
    @Override
    public SimpleParcelable[] ReverseSimpleParcelables(
        SimpleParcelable[] input, SimpleParcelable[] repeated) throws RemoteException {
      SimpleParcelable[] reversed = new SimpleParcelable[input.length];
      for (int i = 0; i < input.length; i++) {
        repeated[i] = input[i];
        reversed[i] = input[input.length - i - 1];
      }
      return reversed;
    }
    @Override
    public PersistableBundle[] ReversePersistableBundles(
        PersistableBundle[] input, PersistableBundle[] repeated) throws RemoteException {
      PersistableBundle[] reversed = new PersistableBundle[input.length];
      for (int i = 0; i < input.length; i++) {
        repeated[i] = input[i];
        reversed[i] = input[input.length - i - 1];
      }
      return reversed;
    }
    @Override
    public Union ReverseUnion(Union input, Union repeated) throws RemoteException {
      int[] repeatedArray = new int[input.getNs().length];
      int[] reversedArray = ReverseInt(input.getNs(), repeatedArray);
      repeated.setNs(repeatedArray);
      return Union.ns(reversedArray);
    }
    @Override
    public List<IBinder> ReverseNamedCallbackList(List<IBinder> input, List<IBinder> repeated)
        throws RemoteException {
      ArrayList<IBinder> reversed = new ArrayList<IBinder>();
      for (IBinder a : input) {
        repeated.add(a);
        reversed.add(0, a);
      }
      return reversed;
    }
    @Override
    public FileDescriptor RepeatFileDescriptor(FileDescriptor read) throws RemoteException {
      return read;
    }
    @Override
    public FileDescriptor[] ReverseFileDescriptorArray(
        FileDescriptor[] input, FileDescriptor[] repeated) throws RemoteException {
      FileDescriptor[] reversed = new FileDescriptor[input.length];
      for (int i = 0; i < input.length; i++) {
        repeated[i] = input[i];
        reversed[i] = input[input.length - i - 1];
      }
      return reversed;
    }
    @Override
    public void TakesAnIBinderList(List<IBinder> input) throws RemoteException {}
    @Override
    public void TakesANullableIBinderList(List<IBinder> input) throws RemoteException {}
    @Override
    public void RepeatExtendableParcelable(ExtendableParcelable ep, ExtendableParcelable ep2)
        throws RemoteException {
      ep2.a = ep.a;
      ep2.b = ep.b;
      // no way to copy currently w/o unparceling
      ep2.ext.setParcelable(ep.ext.getParcelable(MyExt.class));
      ep2.c = ep.c;
      ep2.ext2.setParcelable(null);
    }
  }

  @Override
  public IBinder GetCppJavaTests() throws RemoteException {
    return new MyCppJavaTests();
  }
  @Override
  public byte getBackendType() throws RemoteException {
    return BackendType.JAVA;
  }
}