content: /*
   * Copyright (C) 2016 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.location;
  
  import android.annotation.Nullable;
  import android.annotation.SystemApi;
  import android.hardware.contexthub.V1_0.ContextHub;
  import android.os.Parcel;
  import android.os.Parcelable;
  
  import java.util.Arrays;
  
  /**
   * @hide
   */
  @SystemApi
  public class ContextHubInfo implements Parcelable {
      private int mId;
      private String mName;
      private String mVendor;
      private String mToolchain;
      private int mPlatformVersion;
      private int mToolchainVersion;
      private float mPeakMips;
      private float mStoppedPowerDrawMw;
      private float mSleepPowerDrawMw;
      private float mPeakPowerDrawMw;
      private int mMaxPacketLengthBytes;
      private byte mChreApiMajorVersion;
      private byte mChreApiMinorVersion;
      private short mChrePatchVersion;
      private long mChrePlatformId;
  
      private int[] mSupportedSensors;
  
      private MemoryRegion[] mMemoryRegions;
  
      /*
       * TODO(b/67734082): Deprecate this constructor and mark private fields as final.
       */
      public ContextHubInfo() {
      }
  
      /**
       * @hide
       */
      public ContextHubInfo(ContextHub contextHub) {
          mId = contextHub.hubId;
          mName = contextHub.name;
          mVendor = contextHub.vendor;
          mToolchain = contextHub.toolchain;
          mPlatformVersion = contextHub.platformVersion;
          mToolchainVersion = contextHub.toolchainVersion;
          mPeakMips = contextHub.peakMips;
          mStoppedPowerDrawMw = contextHub.stoppedPowerDrawMw;
          mSleepPowerDrawMw = contextHub.sleepPowerDrawMw;
          mPeakPowerDrawMw = contextHub.peakPowerDrawMw;
          mMaxPacketLengthBytes = contextHub.maxSupportedMsgLen;
          mChrePlatformId = contextHub.chrePlatformId;
          mChreApiMajorVersion = contextHub.chreApiMajorVersion;
          mChreApiMinorVersion = contextHub.chreApiMinorVersion;
          mChrePatchVersion = contextHub.chrePatchVersion;
  
          mSupportedSensors = new int[0];
          mMemoryRegions = new MemoryRegion[0];
      }
  
      /**
       * returns the maximum number of bytes that can be sent per message to the hub
       *
       * @return int - maximum bytes that can be transmitted in a
       *         single packet
       */
      public int getMaxPacketLengthBytes() {
          return mMaxPacketLengthBytes;
      }
  
      /**
       * get the context hub unique identifer
       *
       * @return int - unique system wide identifier
       */
      public int getId() {
          return mId;
      }
  
      /**
       * get a string as a hub name
       *
       * @return String - a name for the hub
       */
      public String getName() {
          return mName;
      }
  
      /**
       * get a string as the vendor name
       *
       * @return String - a name for the vendor
       */
      public String getVendor() {
          return mVendor;
      }
  
      /**
       * get tool chain string
       *
       * @return String - description of the tool chain
       */
      public String getToolchain() {
          return mToolchain;
      }
  
      /**
       * get platform version
       *
       * @return int - platform version number
       */
      public int getPlatformVersion() {
          return mPlatformVersion;
      }
  
      /**
       * get static platform version number
       *
       * @return int - platform version number
       */
      public int getStaticSwVersion() {
          return (mChreApiMajorVersion << 24) | (mChreApiMinorVersion << 16) | (mChrePatchVersion);
      }
  
      /**
       * get the tool chain version
       *
       * @return int - the tool chain version
       */
      public int getToolchainVersion() {
          return mToolchainVersion;
      }
  
      /**
       * get the peak processing mips the hub can support
       *
       * @return float - peak MIPS that this hub can deliver
       */
      public float getPeakMips() {
          return mPeakMips;
      }
  
      /**
       * get the stopped power draw in milliwatts
       * This assumes that the hub enter a stopped state - which is
       * different from the sleep state. Latencies on exiting the
       * sleep state are typically higher and expect to be in multiple
       * milliseconds.
       *
       * @return float - power draw by the hub in stopped state
       */
      public float getStoppedPowerDrawMw() {
          return mStoppedPowerDrawMw;
      }
  
      /**
       * get the power draw of the hub in sleep mode. This assumes
       * that the hub supports a sleep mode in which the power draw is
       * lower than the power consumed when the hub is actively
       * processing. As a guideline, assume that the hub should be
       * able to enter sleep mode if it knows reliably on completion
       * of some task that the next interrupt/scheduled work item is
       * at least 250 milliseconds later.
       *
       * @return float - sleep power draw in milli watts
       */
      public float getSleepPowerDrawMw() {
          return mSleepPowerDrawMw;
      }
  
      /**
       * get the peak powe draw of the hub. This is the power consumed
       * by the hub at maximum load.
       *
       * @return float - peak power draw
       */
      public float getPeakPowerDrawMw() {
          return mPeakPowerDrawMw;
      }
  
      /**
       * get the sensors supported by this hub
       *
       * @return int[] - all the supported sensors on this hub
       *
       * @see ContextHubManager
       */
      public int[] getSupportedSensors() {
          return Arrays.copyOf(mSupportedSensors, mSupportedSensors.length);
      }
  
      /**
       * get the various memory regions on this hub
       *
       * @return MemoryRegion[] - all the memory regions on this hub
       *
       * @see MemoryRegion
       */
      public MemoryRegion[] getMemoryRegions() {
          return Arrays.copyOf(mMemoryRegions, mMemoryRegions.length);
      }
  
      /**
       * @return the CHRE platform ID as defined in chre/version.h
       */
      public long getChrePlatformId() {
          return mChrePlatformId;
      }
  
      /**
       * @return the CHRE API's major version as defined in chre/version.h
       */
      public byte getChreApiMajorVersion() {
          return mChreApiMajorVersion;
      }
  
      /**
       * @return the CHRE API's minor version as defined in chre/version.h
       */
      public byte getChreApiMinorVersion() {
          return mChreApiMinorVersion;
      }
  
      /**
       * @return the CHRE patch version as defined in chre/version.h
       */
      public short getChrePatchVersion() {
          return mChrePatchVersion;
      }
  
      @Override
      public String toString() {
          String retVal = "";
          retVal += "ID/handle : " + mId;
          retVal += ", Name : " + mName;
          retVal += "\n\tVendor : " + mVendor;
          retVal += ", Toolchain : " + mToolchain;
          retVal += ", Toolchain version: 0x" + Integer.toHexString(mToolchainVersion);
          retVal += "\n\tPlatformVersion : 0x" + Integer.toHexString(mPlatformVersion);
          retVal += ", SwVersion : "
                  + mChreApiMajorVersion + "." + mChreApiMinorVersion + "." + mChrePatchVersion;
          retVal += ", CHRE platform ID: 0x" + Long.toHexString(mChrePlatformId);
          retVal += "\n\tPeakMips : " + mPeakMips;
          retVal += ", StoppedPowerDraw : " + mStoppedPowerDrawMw + " mW";
          retVal += ", PeakPowerDraw : " + mPeakPowerDrawMw + " mW";
          retVal += ", MaxPacketLength : " + mMaxPacketLengthBytes + " Bytes";
  
          return retVal;
      }
  
      @Override
      public boolean equals(@Nullable Object object) {
          if (object == this) {
              return true;
          }
  
          boolean isEqual = false;
          if (object instanceof ContextHubInfo) {
              ContextHubInfo other = (ContextHubInfo) object;
              isEqual = (other.getId() == mId)
                      && other.getName().equals(mName)
                      && other.getVendor().equals(mVendor)
                      && other.getToolchain().equals(mToolchain)
                      && (other.getToolchainVersion() == mToolchainVersion)
                      && (other.getStaticSwVersion() == getStaticSwVersion())
                      && (other.getChrePlatformId() == mChrePlatformId)
                      && (other.getPeakMips() == mPeakMips)
                      && (other.getStoppedPowerDrawMw() == mStoppedPowerDrawMw)
                      && (other.getSleepPowerDrawMw() == mSleepPowerDrawMw)
                      && (other.getPeakPowerDrawMw() == mPeakPowerDrawMw)
                      && (other.getMaxPacketLengthBytes() == mMaxPacketLengthBytes)
                      && Arrays.equals(other.getSupportedSensors(), mSupportedSensors)
                      && Arrays.equals(other.getMemoryRegions(), mMemoryRegions);
          }
  
          return isEqual;
      }
  
      private ContextHubInfo(Parcel in) {
          mId = in.readInt();
          mName = in.readString();
          mVendor = in.readString();
          mToolchain = in.readString();
          mPlatformVersion = in.readInt();
          mToolchainVersion = in.readInt();
          mPeakMips = in.readFloat();
          mStoppedPowerDrawMw = in.readFloat();
          mSleepPowerDrawMw = in.readFloat();
          mPeakPowerDrawMw = in.readFloat();
          mMaxPacketLengthBytes = in.readInt();
          mChrePlatformId = in.readLong();
          mChreApiMajorVersion = in.readByte();
          mChreApiMinorVersion = in.readByte();
          mChrePatchVersion = (short) in.readInt();
  
          int numSupportedSensors = in.readInt();
          mSupportedSensors = new int[numSupportedSensors];
          in.readIntArray(mSupportedSensors);
          mMemoryRegions = in.createTypedArray(MemoryRegion.CREATOR);
      }
  
      public int describeContents() {
          return 0;
      }
  
      public void writeToParcel(Parcel out, int flags) {
          out.writeInt(mId);
          out.writeString(mName);
          out.writeString(mVendor);
          out.writeString(mToolchain);
          out.writeInt(mPlatformVersion);
          out.writeInt(mToolchainVersion);
          out.writeFloat(mPeakMips);
          out.writeFloat(mStoppedPowerDrawMw);
          out.writeFloat(mSleepPowerDrawMw);
          out.writeFloat(mPeakPowerDrawMw);
          out.writeInt(mMaxPacketLengthBytes);
          out.writeLong(mChrePlatformId);
          out.writeByte(mChreApiMajorVersion);
          out.writeByte(mChreApiMinorVersion);
          out.writeInt(mChrePatchVersion);
  
          out.writeInt(mSupportedSensors.length);
          out.writeIntArray(mSupportedSensors);
          out.writeTypedArray(mMemoryRegions, flags);
      }
  
      public static final @android.annotation.NonNull Parcelable.Creator<ContextHubInfo> CREATOR
              = new Parcelable.Creator<ContextHubInfo>() {
          public ContextHubInfo createFromParcel(Parcel in) {
              return new ContextHubInfo(in);
          }
  
          public ContextHubInfo[] newArray(int size) {
              return new ContextHubInfo[size];
          }
      };
  }
  