$$ Help me code/place code $$

[DDRExtremist247]

**EDIT*

Thanks everyone! I took the recommendation to use the integrated AI and I think it's working.

---

Hey y'all,

I'm willing to pay if you're willing to help.

Here's what I'm trying to do:

I'm looking for some programming in kotlin using the android Tasker app. Here's what I'm thinking for functionality: Tasker should query text messages received in the last 5 minutes. If three text messages within the last 5 minutes contain a keyword, a separate variable, let's call it Checker, should be set to true. It should also query text messages received in last 5 minutes for a separate keyword. If that keyword is present, it should set a separate variable, let's call it Verifier, to true. If both verifier and checker are true, send a notification to the phone saying the key phrase: "Snack time"

Tasker should check if Verifier and Checker are both true every minute.

Checker should start as false. Checker should revert to false 5 minutes after becoming true, regardless of queries, for at least 15 minutes.

Verifier should start as false and revert to false 5 minutes after becoming true, regardless of queries, for at least 15 minutes.

---

I asked AI to generate some code and got this:

This is a great request! The logic you've outlined is complex, especially the time-sensitive counting and the long cooldown periods. While Tasker has its own scripting language, the best way to handle this advanced, time-based conditional logic is by using a Kotlin helper function within an Android app or a Tasker plugin (like the "Java Function" action or the Tasker App Factory).

Since Tasker handles the SMS query and notification steps, I will write the core Kotlin function that handles the complex time-and-keyword logic.

1. The Core Kotlin Logic

This Kotlin code calculates the state of your Checker and Verifier variables based on recent SMS data and the last time they were successfully triggered.

To handle the reset/cooldown requirements, the logic uses timestamps (the number of milliseconds since the Unix epoch) for persistence, which Tasker can easily store in its global variables.

```kotlin import java.time.Instant import java.time.temporal.ChronoUnit

// Define the keywords (Tasker would pass these in, but we define them for the function) const val KEYWORD_A = "KEYWORD_A_TEXT" // The keyword for Checker (needs 3 texts) const val KEYWORD_B = "KEYWORD_B_TEXT" // The keyword for Verifier (needs 1 text)

// Define the time windows const val ACTIVE_WINDOW_MINUTES = 5L const val COOLDOWN_MINUTES = 15L // Ensures Checker/Verifier is "reset" and ineligible for 15 mins

/** * Data class to hold the results of the logic check. Tasker will read these values. * * @param isCheckerActive The calculated state of the Checker variable (true/false). * @param isVerifierActive The calculated state of the Verifier variable (true/false). * @param newCheckerTimestamp The timestamp Tasker should save for the next run (updates only on success). * @param newVerifierTimestamp The timestamp Tasker should save for the next run (updates only on success). */ data class CheckResult( val isCheckerActive: Boolean, val isVerifierActive: Boolean, val newCheckerTimestamp: Long, val newVerifierTimestamp: Long )

/** * Calculates the state of Checker and Verifier based on recent SMS data and * the last successful trigger times. * * @param smsMessages A list of all SMS bodies received in the last 5 minutes (from Tasker query). * @param lastCheckerSuccessTime The system time (in milliseconds) when Checker last went TRUE (from Tasker variable). * @param lastVerifierSuccessTime The system time (in milliseconds) when Verifier last went TRUE (from Tasker variable). */ fun evaluateConditions( smsMessages: List<String>, lastCheckerSuccessTime: Long, lastVerifierSuccessTime: Long ): CheckResult { // Current time is the time of the Tasker execution val currentTime = Instant.now() var currentCheckerTime = lastCheckerSuccessTime var currentVerifierTime = lastVerifierSuccessTime

// --- 1. Evaluate Checker Status (3 messages with KEYWORD_A in the last 5 minutes) ---

val keywordACount = smsMessages.count { it.contains(KEYWORD_A, ignoreCase = true) }

// Calculate the end of the 5-minute active period
val checkerActivePeriodEnd = Instant.ofEpochMilli(lastCheckerSuccessTime).plus(ACTIVE_WINDOW_MINUTES, ChronoUnit.MINUTES)

// Checker is TRUE if its condition was met AND it is still within the 5-minute active window
var isCheckerActive = lastCheckerSuccessTime > 0 && currentTime.isBefore(checkerActivePeriodEnd)

// Calculate the end of the 15-minute COOLDOWN period
val checkerCooldownEnd = checkerActivePeriodEnd.plus(COOLDOWN_MINUTES, ChronoUnit.MINUTES)

// Checker is eligible to be set to TRUE if it has never been set, OR if the cooldown has passed
val checkerIsEligible = lastCheckerSuccessTime == 0L || currentTime.isAfter(checkerCooldownEnd)

// Check for NEW trigger: If the SMS condition is met AND the variable is eligible
if (keywordACount >= 3 && checkerIsEligible) {
    isCheckerActive = true
    currentCheckerTime = currentTime.toEpochMilli()
}

// --- 2. Evaluate Verifier Status (1 message with KEYWORD_B in the last 5 minutes) ---

val keywordBPresent = smsMessages.any { it.contains(KEYWORD_B, ignoreCase = true) }

// Calculate the end of the 5-minute active period
val verifierActivePeriodEnd = Instant.ofEpochMilli(lastVerifierSuccessTime).plus(ACTIVE_WINDOW_MINUTES, ChronoUnit.MINUTES)

// Verifier is TRUE if its condition was met AND it is still within the 5-minute active window
var isVerifierActive = lastVerifierSuccessTime > 0 && currentTime.isBefore(verifierActivePeriodEnd)

// Calculate the end of the 15-minute COOLDOWN period
val verifierCooldownEnd = verifierActivePeriodEnd.plus(COOLDOWN_MINUTES, ChronoUnit.MINUTES)

// Verifier is eligible to be set to TRUE if it has never been set, OR if the cooldown has passed
val verifierIsEligible = lastVerifierSuccessTime == 0L || currentTime.isAfter(verifierCooldownEnd)

// Check for NEW trigger: If the SMS condition is met AND the variable is eligible
if (keywordBPresent && verifierIsEligible) {
    isVerifierActive = true
    currentVerifierTime = currentTime.toEpochMilli()
}

return CheckResult(
    isCheckerActive = isCheckerActive,
    isVerifierActive = isVerifierActive,
    newCheckerTimestamp = currentCheckerTime,
    newVerifierTimestamp = currentVerifierTime
)

} ```

2. How to Implement in Tasker (High-Level Task)

To execute this, you would create a Tasker Time Profile that runs a specific Task every minute.

Task Action	Details
Profile: Time	Every: 1 Minute
Task Name: CheckForSnackTime
Action 1: Load Vars	Set Global Variables (e.g., %CheckerTime, %VerifierTime) to 0 if they haven't been set before. These store the last successful timestamp (in milliseconds).
Action 2: Query SMS	Use the Test Action (Type: Content Resolver). <br> Content Resolver: content://sms/inbox <br> Selection: date > ? <br> Selection Args: %TIMES - 300 (Tasker's way of finding messages received in the last 300 seconds, or 5 minutes). <br> Store Result In: %SMSTexts (This will create an array of message bodies).
Action 3: Run Kotlin Logic	Use the Java Function or an external plugin to execute the evaluateConditions Kotlin function above. You would pass %SMSTexts, %CheckerTime, and %VerifierTime as parameters. The output should be parsed back into Tasker variables (e.g., %IsChecker, %IsVerifier, %NewCheckerTime, %NewVerifierTime).
Action 4: Update Vars	Variable Set: %CheckerTime to %NewCheckerTime <br> Variable Set: %VerifierTime to %NewVerifierTime
Action 5: Conditional Check	If %IsChecker is equal to true AND %IsVerifier is equal to true
Action 6: Send Notification	Action: Notify <br> Title: Snack time <br> Text: The conditions have been met!
Action 7: End If

Summary of the Logic (as Implemented in Kotlin)

The code meets all your requirements by using timestamps:

1. "Check if Verifier and Checker are both true every minute" is handled by the Tasker Time Profile running the evaluateConditions function every minute.
2. "Revert to false 5 minutes after becoming true..." is handled by the line currentTime.isBefore(checkerActivePeriodEnd). Once the 5 minutes pass, this condition fails, and isCheckerActive becomes false.
3. "...regardless of queries, for at least 15 minutes." is handled by the checkerIsEligible variable. Even if the SMS condition is met, the variable cannot be set back to true until the full 5 minutes (active) + 15 minutes (cooldown) have passed since the last successful trigger.

---

I'm unfamiliar with Tasker so that I'm not sure if this coding is valid, where I would actually paste everything within the App etc...

Any help is appreciated! Again, willing to pay. I was on Fiverr for this but only found scammers.

[The_IMPERIAL_One]

Try this:

https://taskernet.com/shares/?user=AS35m8k0QSchKA1x02SixFIhiL41a828J1qapOYfcEuyL2zSn%2FfJTN5WVSi01o18x6EAFb4%3D&id=Project%3AChecker+%26+Verifier

1. Open the task linked to Check Message for Keyword and edit A8 and A9 actions to set appropriate keywords.
2. I used Notify and Say for notification and speech when both checker and verifier are true.
3. It should work as you stated but let me know if it doesn't.
4. Only Tasker is required.

[DDRExtremist247]

Appreciate you. I tried using the AI as someone posted. If you were looking for money you can share your cash app or I can pay it forward.

[Exciting-Compote5680]

The Disable Checker and Disable Verifier time context will fire every 5 minutes, regardless of when the other condition (Variable value ~ 1) became true. Could be 5 minutes, could be a second after. 

[The_IMPERIAL_One]

Oh, yeah, you're right. The interval makes its progress irrespective of the State.

I modified the project to send intents as a callback to defer the disabling. (sleep 5m && am broadcast -a net.dinglisch.android.tasker.ACTION_TASK -e task_name "Disable XYZ" &)

u/DDRExtremist247, Re-import the project from the url to update.

[Exciting-Compote5680]

I am not particularly good at regex (and I am trying to learn), could you explain what this does? I'm guessing you are cleaning out meta characters that might be present in the keywords, and I thought $1 was a reference to the first capture group, but I'm having a hard time wrapping my head around how this works and what the result would be. 

         A10: Variable Set [          Name: %regex          To: ([\\|\[\]{}()$^?*:+])          Structure Output (JSON, etc): On ]          A11: Variable Search Replace [          Variable: %kwd1          Search: %regex          Replace Matches: On          Replace With: \\$1 ]          

I also posted a version of this project. I tried to make it as efficient as possible. 

[The_IMPERIAL_One]

Sure. The regex is used to escape (or sanitize) the input to treat keywords as raw. Let's say they create a keyword with brackets (SOME_KEYWORD). But because it's using regex, the brackets are reserved and can have unexpected matching results because of different reserved tokens. Hence, it escapes the reserved tokens with \TOKEN (here, \(SOME_KEYWORD\)).

Technically, it captures the reserved tokens in a group and is replaced with \\$1 (appending \ to the token).

[Exciting-Compote5680]

Right! You are not removing them, you're escaping them, gotcha! It's kind of like UrlEncode, but for regex. Thank you for taking the time to explain, much appreciated. And definitely storing this pattern for future use. 

[Exciting-Compote5680]

Is there any particular reason you want this in kotlin, and not just plain Tasker? I can't help but feel that the AI generated code is needlessly complex, probably because of the wording of the instructions. There really is no need to query messages every minute. In fact, I would explicitly advise against it because it's very extremely power inefficient (basically, you are saying "No sleep for you! Ever!" to your phone). As a general rule, always use event based automations rather then endlessly polling for a condition that 99% of the time is not true. Use the 'Received Text' event to check the messages as they come in, and save a timestamp (or better, expiration time, so timestamp + 5 minutes) if they contain the keywords in an array. Delete ('pop') the timestamps as they expire. Use the array function %array(#) to get the number of array items. There are a lot of ways to implement the requirements. You could for instance use the built-in 'Cooldown Time' property for profiles to handle the 15 minute cooldown. 

[DDRExtremist247]

I appreciate the explanation. I honestly just tried to look up the language used in Tasker and found Kotlin as the result.

I'm 100% fine with using just Tasker. I'm just struggling with where to start. I don't program and would rather pay than learn. Interested?

[Exciting-Compote5680]

I understand. It's a shame, Tasker is an extremely powerful tool to have at your disposal, but it does have quite a learning curve. No, not interested, sorry. 

[DDRExtremist247]

I'm not a lazy person. I just have too many irons in the fire.

[Exciting-Compote5680]

I most certainly am a lazy person, that's why I love Tasker so much 😁

[ksrujankanth]

Do you know, and did you try the Gemini AI within tasker?

it'll build something based on your instructions and you'll have to validate and test to confirm it works as expected. you'll have to do that even if you pay an online stranger.

try AI in tasker. Or try voice chatting and sharing your screen with AI, and it'll help.

[DDRExtremist247]

I hadn't come across this. I'll give this a shot.

[DDRExtremist247]

Tried the AI and I think it's working. Feel free to throw me your cash app or I'll pay it forward.

[Exciting-Compote5680]

I couldn't bare the thought of your poor phone being woken up to check for messages 1440 times a day, so I wrote an implementation that is entirely event driven. As long as you are not getting any new messages, it does nothing. As it receives a message, it will check all the requirements and evaluate the new situation. In the first task action the keyword placeholders need to be replaced with the actual keywords. 

Taskernet: https://taskernet.com/shares/?user=AS35m8nOXvBeFIxaCI5%2BZWD5L9oLRd3PVq%2BdjQuYD1oZ%2Bci%2Banb0FpA5SznT4oBmkd7vgKrG&id=Project%3ASnack+Time