diff options
| -rw-r--r-- | core/java/android/hardware/location/ContextHubIntentEvent.java | 224 |
1 files changed, 224 insertions, 0 deletions
diff --git a/core/java/android/hardware/location/ContextHubIntentEvent.java b/core/java/android/hardware/location/ContextHubIntentEvent.java new file mode 100644 index 000000000000..96e74969a2e8 --- /dev/null +++ b/core/java/android/hardware/location/ContextHubIntentEvent.java @@ -0,0 +1,224 @@ +/* + * Copyright 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 android.hardware.location; + +import android.annotation.NonNull; +import android.app.PendingIntent; +import android.content.Intent; + +import com.android.internal.util.Preconditions; + +/** + * A helper class to retrieve information about a Intent event received for a PendingIntent + * registered through {@link ContextHubClient.registerIntent(PendingIntent, long)}. This object + * can only be created through the factory method {@link ContextHubIntentEvent.fromIntent(Intent)}. + * + * @hide + */ +public class ContextHubIntentEvent { + @ContextHubManager.Event private final int mEventType; + + @NonNull private final ContextHubInfo mContextHubInfo; + + private final long mNanoAppId; + + private final NanoAppMessage mNanoAppMessage; + + private final int mNanoAppAbortCode; + + private ContextHubIntentEvent( + @NonNull ContextHubInfo contextHubInfo, @ContextHubManager.Event int eventType, + long nanoAppId, NanoAppMessage nanoAppMessage, int nanoAppAbortCode) { + mContextHubInfo = contextHubInfo; + mEventType = eventType; + mNanoAppId = nanoAppId; + mNanoAppMessage = nanoAppMessage; + mNanoAppAbortCode = nanoAppAbortCode; + } + + private ContextHubIntentEvent( + @NonNull ContextHubInfo contextHubInfo, @ContextHubManager.Event int eventType) { + this(contextHubInfo, eventType, -1 /* nanoAppId */, null /* nanoAppMessage */, + -1 /* nanoAppAbortCode */); + } + + private ContextHubIntentEvent( + @NonNull ContextHubInfo contextHubInfo, @ContextHubManager.Event int eventType, + long nanoAppId) { + this(contextHubInfo, eventType, nanoAppId, null /* nanoAppMessage */, + -1 /* nanoAppAbortCode */); + } + + private ContextHubIntentEvent( + @NonNull ContextHubInfo contextHubInfo, @ContextHubManager.Event int eventType, + long nanoAppId, @NonNull NanoAppMessage nanoAppMessage) { + this(contextHubInfo, eventType, nanoAppId, nanoAppMessage, -1 /* nanoAppAbortCode */); + } + + private ContextHubIntentEvent( + @NonNull ContextHubInfo contextHubInfo, @ContextHubManager.Event int eventType, + long nanoAppId, int nanoAppAbortCode) { + this(contextHubInfo, eventType, nanoAppId, null /* nanoAppMessage */, nanoAppAbortCode); + } + + /** + * Creates a ContextHubIntentEvent object from an Intent received through a PendingIntent + * registered through {@link ContextHubClient.registerIntent(PendingIntent, long)}. + * + * @param intent the Intent object from an Intent event + * @return the ContextHubIntentEvent object describing the event + * + * @throws IllegalArgumentException if the Intent was not a valid intent + */ + @NonNull + public static ContextHubIntentEvent fromIntent(@NonNull Intent intent) { + Preconditions.checkNotNull(intent, "Intent cannot be null"); + + hasExtraOrThrow(intent, ContextHubManager.EXTRA_CONTEXT_HUB_INFO); + ContextHubInfo info = intent.getParcelableExtra(ContextHubManager.EXTRA_CONTEXT_HUB_INFO); + if (info == null) { + throw new IllegalArgumentException("ContextHubInfo extra was null"); + } + + int eventType = getIntExtraOrThrow(intent, ContextHubManager.EXTRA_EVENT_TYPE); + ContextHubIntentEvent event; + switch (eventType) { + case ContextHubManager.EVENT_NANOAPP_LOADED: + case ContextHubManager.EVENT_NANOAPP_UNLOADED: + case ContextHubManager.EVENT_NANOAPP_ENABLED: + case ContextHubManager.EVENT_NANOAPP_DISABLED: + case ContextHubManager.EVENT_NANOAPP_ABORTED: + case ContextHubManager.EVENT_NANOAPP_MESSAGE: // fall through + long nanoAppId = getLongExtraOrThrow(intent, ContextHubManager.EXTRA_NANOAPP_ID); + if (eventType == ContextHubManager.EVENT_NANOAPP_MESSAGE) { + hasExtraOrThrow(intent, ContextHubManager.EXTRA_MESSAGE); + NanoAppMessage message = + intent.getParcelableExtra(ContextHubManager.EXTRA_MESSAGE); + if (message == null) { + throw new IllegalArgumentException("NanoAppMessage extra was null"); + } + + event = new ContextHubIntentEvent(info, eventType, nanoAppId, message); + } else if (eventType == ContextHubManager.EVENT_NANOAPP_ABORTED) { + int nanoAppAbortCode = getIntExtraOrThrow( + intent, ContextHubManager.EXTRA_NANOAPP_ABORT_CODE); + event = new ContextHubIntentEvent(info, eventType, nanoAppId, nanoAppAbortCode); + } else { + event = new ContextHubIntentEvent(info, eventType, nanoAppId); + } + break; + + case ContextHubManager.EVENT_HUB_RESET: + event = new ContextHubIntentEvent(info, eventType); + break; + + default: + throw new IllegalArgumentException("Unknown intent event type " + eventType); + } + + return event; + } + + /** + * @return the event type of this Intent event + */ + @ContextHubManager.Event + public int getEventType() { + return mEventType; + } + + /** + * @return the ContextHubInfo object describing the Context Hub this event was for + */ + @NonNull + public ContextHubInfo getContextHubInfo() { + return mContextHubInfo; + } + + /** + * @return the ID of the nanoapp this event was for + * + * @throws UnsupportedOperationException if the event did not have a nanoapp associated + */ + public long getNanoAppId() { + if (mEventType == ContextHubManager.EVENT_HUB_RESET) { + throw new UnsupportedOperationException( + "Cannot invoke getNanoAppId() on Context Hub reset event"); + } + return mNanoAppId; + } + + /** + * @return the nanoapp's abort code + * + * @throws UnsupportedOperationException if this was not a nanoapp abort event + */ + public int getNanoAppAbortCode() { + if (mEventType != ContextHubManager.EVENT_NANOAPP_ABORTED) { + throw new UnsupportedOperationException( + "Cannot invoke getNanoAppAbortCode() on non-abort event: " + mEventType); + } + return mNanoAppAbortCode; + } + + /** + * @return the message from a nanoapp + * + * @throws UnsupportedOperationException if this was not a nanoapp message event + */ + @NonNull + public NanoAppMessage getNanoAppMessage() { + if (mEventType != ContextHubManager.EVENT_NANOAPP_MESSAGE) { + throw new UnsupportedOperationException( + "Cannot invoke getNanoAppMessage() on non-message event: " + mEventType); + } + return mNanoAppMessage; + } + + @Override + public String toString() { + String out = "ContextHubIntentEvent[eventType = " + mEventType + + ", contextHubId = " + mContextHubInfo.getId(); + + if (mEventType != ContextHubManager.EVENT_HUB_RESET) { + out += ", nanoAppId = 0x" + Long.toHexString(mNanoAppId); + } + if (mEventType == ContextHubManager.EVENT_NANOAPP_ABORTED) { + out += ", nanoAppAbortCode = " + mNanoAppAbortCode; + } + if (mEventType == ContextHubManager.EVENT_NANOAPP_MESSAGE) { + out += ", nanoAppMessage = " + mNanoAppMessage; + } + + return out + "]"; + } + + private static void hasExtraOrThrow(Intent intent, String extra) { + if (!intent.hasExtra(extra)) { + throw new IllegalArgumentException("Intent did not have extra: " + extra); + } + } + + private static int getIntExtraOrThrow(Intent intent, String extra) { + hasExtraOrThrow(intent, extra); + return intent.getIntExtra(extra, -1 /* defaultValue */); + } + + private static long getLongExtraOrThrow(Intent intent, String extra) { + hasExtraOrThrow(intent, extra); + return intent.getLongExtra(extra, -1 /* defaultValue */); + } +} |