WebSVN – SmartDukaan – Diff – //trunk/profitmandi-cron/src/main/java/com/smartdukaan/cron/scheduled/CheckOppoWarrantyTask.java

                             String fileName = "/tmp/oppo-simple-i-" + counter + " " + System.currentTimeMillis() + ".png";
                             try {
                                 LOGGER.info("Starting Do");
                                 wait10Sec.until(ExpectedConditions.visibilityOfElementLocated(By.xpath("//*[starts-with(@id, 'dx_captcha_basic_wrapper_')]")));
                                 wait10Sec.until(ExpectedConditions.visibilityOfElementLocated(By.xpath("//*[starts-with(@id, 'dx_captcha_basic_slider_')]")));
-                                slideButton = driver.findElement(By.xpath("//*[starts-with(@id, 'dx_captcha_basic_slider_')]"));
+                                By sliderBy = By.xpath("//*[starts-with(@id, 'dx_captcha_basic_slider_')]");
-                                //System.out.println("Slide button - " + slideButton);
+                                slideButton = driver.findElement(sliderBy);
-                                LOGGER.info("Margin Left before- " + slideButton.getCssValue("margin-left"));
+                                LOGGER.info("Margin Left before- " + marginLeftOf(slideButton));
+                                try {
+                                    actionProvider.moveToElement(slideButton).clickAndHold()
+                                            .moveByOffset(1, 0)
+                                            .perform();
+                                } catch (StaleElementReferenceException stale) {
+                                    // The retry refresh (doubleClick at the end of the previous
+                                    // attempt) swaps the widget's DOM, so the handle located at the
+                                    // top of THIS attempt can already be detached by the time we act
+                                    // on it. Re-find and try once, rather than abandoning the imei
+                                    // and reloading the page: this killed 19% of oppo attempts
+                                    // (54 of 284), against 0 on realme.
+                                    LOGGER.info("Slider went stale before the drag - re-finding and retrying once");
+                                    slideButton = driver.findElement(sliderBy);
-                                actionProvider.moveToElement(slideButton).clickAndHold()
+                                    actionProvider.moveToElement(slideButton).clickAndHold()
-                                        .moveByOffset(1, 0)//.pause(2000)
+                                            .moveByOffset(1, 0)
-                                        .perform();
+                                            .perform();
+                                }
                                 pressed = true;
-                                //actionProvider.moveByOffset(-1,0).pause(2000).perform();
-                                LOGGER.info("Margin Left after - " + slideButton.getCssValue("margin-left"));
+                                LOGGER.info("Margin Left after - " + marginLeftOf(slideButton));
                                 //Thread.sleep(5000);
                             } catch (Exception e) {
                                 LOGGER.warn("Slider captcha widget (dx_captcha_basic_*) not found or not draggable"
                                         + " - reloading. Cause: " + e.getMessage());
                                 driver.get("https://support.oppo.com/in/warranty-check/");
                                 double firstCircleX = circles[0];
                                 double secondCircleX = circles[1];
                                 double distance = Math.abs(firstCircleX - secondCircleX);
                                 LOGGER.info("Distance is " + distance);
-                                double[] cal = calibrate(driver, actionProvider, distance);
+                                // Closed loop: no assumed ratio, every move re-measures.
-                                int moveByOffset = cal == null ? 0 : (int) cal[0];
+                                int moveByOffset = aim(driver, actionProvider, distance);
                                 if (moveByOffset > 0) {
-                                    // Move, then measure again and close the remainder BEFORE
-                                    // releasing. Releasing on the first computed offset committed
-                                    // the whole calibration error to the final position.
-                                    actionProvider.moveByOffset(moveByOffset, 0).perform();
-                                    refine(driver, actionProvider, cal[1]);
                                     actionProvider.release().perform();
                                     pressed = false;
                                     LOGGER.info("Move click performed (main {}px)", moveByOffset);
                                     try {
                                         try {
+     *
      * Aim to close about half the gap: the piece travels roughly ASSUMED_RATIO px per
      * slider px, so nudge ~= gap / (2 * ratio), clamped. The real ratio is still derived
      * from the measurement; this only sizes the probe.
      */
-    /*
-     * These are OPPO's tuning values and are deliberately independent of realme's.
-     * The two classes drive the same dingxiang widget but convert very differently
-     * (oppo ~12%, realme ~60% of completed drags), so a change proven on one is NOT
-     * evidence for the other. Tune and measure them separately.
-     *
-     * Back to 1.7 after r37433 set this to 0.67 and it did not help (14% -> 13%).
-     *
-     * 0.67 was fitted to 3,694 production calibrations -- but every one of those was
-     * measured while the slider press was being leaked between attempts (r37435), so the
-     * sample was contaminated and the value fitted to noise.
-     *
-     * With that confound removed the clean evidence is realme: identical widget, same
-     * calibration code, ASSUMED_RATIO 1.7, converting 82%. Measured post-fix on similar
-     * gaps, 1.7 probes ~31px and closes ~11% of the gap, while 0.67 probes ~52px and
-     * closes ~37%. The SMALLER probe is the one that lands -- a probe that eats a third
-     * of the gap risks crossing the target during calibration, and |c1-c2| cannot tell
-     * "not there yet" from "gone past", so the derived ratio comes back wrong.
-     */
-    private static final double ASSUMED_RATIO = 1.7;
-    private static final int MIN_NUDGE = 10;
-    private static final int MAX_NUDGE = 60;
     private static final double ALIGNED_PX = 2.0;
-    private static int nudgeFor(double gap) {
-        int n = (int) Math.round(gap / (2 * ASSUMED_RATIO));
-        return Math.max(MIN_NUDGE, Math.min(MAX_NUDGE, n));
-    }
     /**
-     * @return {sliderPxToMove, sliderPxPerCirclePx}, or null when the circles could not
+     * margin-left for logging only. Reading it off a detached element throws, and this is
-     *         be read. Returned rather than stored on a field: this is a singleton and
+     * a diagnostic -- it must never be the reason an attempt is abandoned.
-     *         the Oppo secondary and tertiary jobs run it concurrently.
      */
-    private double[] calibrate(WebDriver driver, Actions actionProvider, double distance) throws Exception {
-        int nudge = nudgeFor(distance);
-        actionProvider.moveByOffset(nudge, 0).perform();
+    private String marginLeftOf(WebElement el) {
-        String fileName2 = "/tmp/" + Thread.currentThread().getName() + "-moved.png";
-        double[] movedCircles = getMatCircles2(driver, fileName2);
-        if (movedCircles == null) return null;
+        try {
-        double movedDistance = Math.abs(movedCircles[0] - movedCircles[1]);
-        double closed = distance - movedDistance;
+            return el.getCssValue("margin-left");
-        LOGGER.info("Calibration: gap {} -> {} after {}px, closed {}",
-                distance, movedDistance, nudge, closed);
+        } catch (Exception e) {
-        // A non-positive value means the piece did not move, or moved away from the
-        // hole -- either way the ratio is meaningless and guessing would waste the try.
-        if (closed <= 0) return null;
+            return "?";
-        double sliderPerCircle = nudge / closed;
+        }
-        int moveBy = (int) Math.round(movedDistance * sliderPerCircle);
-        return new double[]{moveBy, sliderPerCircle};
+    }
+    /** Seed probe, in slider px. Deliberately small: it only has to produce a first
+     *  measurable movement, and it must be too small to cross the hole. */
+    private static final int SEED_NUDGE = 12;
+    private static final int MAX_AIM_STEPS = 5;
+    private static final int MAX_STEP = 140;
     /**
+     * Drag onto the hole without ever assuming a ratio.
+     *
+     * The old path derived px-per-px ONCE from a single probe and then trusted it for
+     * the main move and the correction alike, so one noisy probe poisoned everything
+     * downstream. Here every move is also a measurement: after each one the ratio is
-     * Measure again after the main move and close whatever is left. The old code
+     * re-derived from what that move actually achieved, so the estimate improves as the
-     * committed its single computed offset blind, so any calibration error went
+     * piece approaches instead of being fixed at its least informed point.
+     *
+     * It also gets to see overshoot, which a single pass cannot. The gap is |c1 - c2|,
+     * so it cannot tell "not there yet" from "gone past" -- but if a move makes the gap
-     * straight into the final position with nothing to catch it.
+     * GROW, we crossed the hole, and the sign of the next step flips.
+     *
+     * @return total slider px moved, or 0 if the circles could not be read at all.
      */
-    private int refine(WebDriver driver, Actions actionProvider, double sliderPerCircle) throws Exception {
+    private int aim(WebDriver driver, Actions actionProvider, double gap) throws Exception {
+        double ratio = 0;               // slider px per gap px, derived from real moves
+        int total = 0;
+        int step = SEED_NUDGE;
+        for (int i = 0; i < MAX_AIM_STEPS; i++) {
+            actionProvider.moveByOffset(step, 0).perform();
+            total += step;
-        String fileName = "/tmp/" + Thread.currentThread().getName() + "-refine.png";
+            double[] c = getMatCircles2(driver, "/tmp/" + Thread.currentThread().getName() + "-aim" + i + ".png");
+            if (c == null) {
+                LOGGER.warn("Aim step {}: lost the circles after {}px", i, total);
+                return total;
+            }
-        double[] circles = getMatCircles2(driver, fileName);
+            double now = Math.abs(c[0] - c[1]);
-        if (circles == null) return 0;
+            double closed = gap - now;
+            if (closed != 0) {
+                // What this move actually bought us, in slider px per gap px.
-        double remaining = Math.abs(circles[0] - circles[1]);
+                double observed = Math.abs(step) / Math.abs(closed);
+                // Blend once an estimate exists, so a single bad frame cannot swing it.
+                ratio = (ratio <= 0) ? observed : (ratio + observed) / 2;
+            }
+            LOGGER.info("Aim step {}: moved {}px, gap {} -> {}, ratio now {}",
+                    i, step, gap, now, String.format("%.2f", ratio));
-        if (remaining <= ALIGNED_PX) return 0;
+            if (now <= ALIGNED_PX) {
+                LOGGER.info("Aim: aligned within {}px after {} step(s), {}px total", ALIGNED_PX, i + 1, total);
+                return total;
+            }
+            if (ratio <= 0) {                       // nothing measurable yet, probe again
+                gap = now;
+                step = SEED_NUDGE;
+                continue;
+            }
-        int correction = (int) Math.round(remaining * sliderPerCircle);
+            int next = (int) Math.round(now * ratio);
-        if (correction == 0) return 0;
+            if (next == 0) next = 1;
+            if (next > MAX_STEP) next = MAX_STEP;
-        LOGGER.info("Refine: {}px of gap left -> nudging {}px", remaining, correction);
+            // Gap grew => we are past the hole; go back instead of further away.
-        actionProvider.moveByOffset(correction, 0).perform();
+            step = (closed < 0) ? -next : next;
+            gap = now;
+        }
+        LOGGER.info("Aim: {} steps used, {}px total", MAX_AIM_STEPS, total);
-        return correction;
+        return total;
+    }
     private Mat getMatCircles(WebDriver driver, String fileName) throws Exception {
         File screenshot = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
         BufferedImage fullImg = ImageIO.read(screenshot);

Subversion Repositories SmartDukaan

(root)//trunk/profitmandi-cron/src/main/java/com/smartdukaan/cron/scheduled/CheckOppoWarrantyTask.java – Rev 37436 → 37437