/*
 * Copyright (C) 2019 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 com.android.systemui.plugins;

import android.annotation.IntDef;
import android.net.Uri;
import android.view.MotionEvent;

import com.android.systemui.plugins.annotations.ProvidesInterface;

import java.io.PrintWriter;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

/**
 * Interface that decides whether a touch on the phone was accidental. i.e. Pocket Dialing.
 *
 * {@see com.android.systemui.classifier.BrightLineFalsingManager}
 */
@ProvidesInterface(version = FalsingManager.VERSION)
public interface FalsingManager {
    int VERSION = 6;

    int NO_PENALTY = 0;
    int LOW_PENALTY = 1;
    int MODERATE_PENALTY = 2;
    int HIGH_PENALTY = 3;

    @IntDef({
            NO_PENALTY,
            LOW_PENALTY,
            MODERATE_PENALTY,
            HIGH_PENALTY
    })
    @Retention(RetentionPolicy.SOURCE)
    public @interface Penalty {}

    void onSuccessfulUnlock();

    boolean isUnlockingDisabled();

    /** Returns true if the gesture should be rejected. */
    boolean isFalseTouch(int interactionType);

    /**
     * Does basic checking to see if gesture looks like a tap.
     *
     * Only does the most basic of checks. No penalty is applied if this method returns false.
     *
     * For more robust analysis, use {@link #isFalseTap(int)}.
     */
    boolean isSimpleTap();

    /**
     * Returns true if the FalsingManager thinks the last gesture was not a valid tap.
     *
     * This method runs a more thorough analysis than the similar {@link #isSimpleTap()},
     * that can include historical interactions and other contextual cues to see
     * if the tap looks accidental.
     *
     * Use this method to validate a tap for launching an action, like opening
     * a notification.
     *
     * The only parameter, penalty, indicates how much this should affect future gesture
     * classifications if this tap looks like a false. As single taps are hard to confirm as false
     * or otherwise, a low penalty value is encouraged unless context indicates otherwise.
     */
    boolean isFalseTap(@Penalty int penalty);

    /**
     * Returns true if the FalsingManager thinks the last gesture was not a valid long tap.
     *
     * Use this method to validate a long tap for launching an action, like long press on a UMO
     *
     * The only parameter, penalty, indicates how much this should affect future gesture
     * classifications if this long tap looks like a false.
     * As long taps are hard to confirm as false or otherwise,
     * a low penalty value is encouraged unless context indicates otherwise.
     */
    boolean isFalseLongTap(@Penalty int penalty);

    /**
     * Returns true if the last two gestures do not look like a double tap.
     *
     * Only works on data that has already been reported to the FalsingManager. Be sure that
     * {@link com.android.systemui.classifier.FalsingCollector#onTouchEvent(MotionEvent)}
     * has already been called for all of the taps you want considered.
     *
     * This looks at the last two gestures on the screen, ensuring that they meet the following
     * criteria:
     *
     *   a) There are at least two gestures.
     *   b) The last two gestures look like taps.
     *   c) The last two gestures look like a double tap taken together.
     *
     *   This method is _not_ context aware. That is to say, if two taps occur on two neighboring
     *   views, but are otherwise close to one another, this will report a successful double tap.
     *   It is up to the caller to decide
     * @return
     */
    boolean isFalseDoubleTap();

    /**
     * Whether the last proximity event reported NEAR. May be used to short circuit motion events
     * that require the proximity sensor is not covered.
     */
    boolean isProximityNear();

    boolean isClassifierEnabled();

    boolean shouldEnforceBouncer();

    Uri reportRejectedTouch();

    boolean isReportingEnabled();

    /** From com.android.systemui.Dumpable. */
    void dump(PrintWriter pw, String[] args);

    /**
     *  Don't call this. It's meant for internal use to allow switching between implementations.
     *
     * Tests may also call it.
     **/
    void cleanupInternal();

    /** Call to report a ProximityEvent to the FalsingManager. */
    void onProximityEvent(ProximityEvent proximityEvent);

    /** Adds a {@link FalsingBeliefListener}. */
    void addFalsingBeliefListener(FalsingBeliefListener listener);

    /** Removes a {@link FalsingBeliefListener}. */
    void removeFalsingBeliefListener(FalsingBeliefListener listener);

    /** Adds a {@link FalsingTapListener}. */
    void addTapListener(FalsingTapListener falsingTapListener);

    /** Removes a {@link FalsingTapListener}. */
    void removeTapListener(FalsingTapListener falsingTapListener);

    /** Listener that is alerted when falsing belief level crosses a predfined threshold. */
    interface FalsingBeliefListener {
        void onFalse();
    }

    /**
     * Listener that is alerted when an additional tap is required to confirm a single tap.
     **/
    interface FalsingTapListener {
        void onAdditionalTapRequired();
    }

    /** Passed to {@link FalsingManager#onProximityEvent}. */
    interface ProximityEvent {
        /** Returns true when the proximity sensor was covered. */
        boolean getCovered();

        /** Returns when the proximity sensor was covered in nanoseconds. */
        long getTimestampNs();
    }
}