tech&Life

AI Agents at Two Speeds: ReAct for Simple Tasks, Deep Agents for Complex Work

2026-06-16T00:00:00-04:00

AI Agents at Two Speeds: ReAct for Simple Tasks, Deep Agents for Complex Work

Imagine a customer support refund assistant that reads a customer message, looks up refund policy, checks order status, decides whether to refund, escalate, or deny, drafts a customer-facing response, and logs the decision. The same problem can be implemented either way because both approaches let a model call tools. The difference is how much process you want around those tool calls.

Most AI agent discussions get technical quickly: prompts, tools, graphs, memory, orchestration. But for teams deciding what to build, the practical question is simpler: how much agent do you actually need? A customer refund assistant is a useful test case because it is familiar, operational, and easy to scale from simple to complex. The same assistant can be built as a lightweight ReAct-style agent that checks policy and responds, or as a Deep Agent that plans, delegates, tracks context, and leaves an audit trail. This article compares both approaches using that single example, so the tradeoff is clear: start simple when the work is simple, and move deeper when the workflow demands it.

A ReAct-style agent is the lightweight option: it reasons, calls a tool, reads the result, and repeats until it can answer. A Deep Agent is the heavier operations option: it still uses tools, but adds planning, richer context management, subagents, working files, and orchestration for longer-running tasks. For a refund assistant, ReAct is often enough when the policy is simple and the answer is immediate. Deep Agents make more sense when the same refund workflow starts to involve exceptions, audit notes, specialist review, long context, or multiple workstreams.

LangChain ReAct approach

ReAct means "reason and act." In practice, the agent loop asks the model what to do next, calls a tool if needed, gives the tool result back to the model as an observation, and continues until the model returns a final answer. In current LangChain v1, the recommended API for this lightweight agent loop is langchain.agents.create_agent; the older langgraph.prebuilt.create_react_agent path has been replaced for most new work.

flowchart LR
    A[Customer message] --> B[ReAct-style agent loop]
    B --> C{Need more information?}
    C -->|Order status| D[check_order_status]
    C -->|Refund rules| E[lookup_refund_policy]
    D --> B
    E --> B
    B --> F[Draft response]
    F --> G[log_refund_decision]
    G --> H[Final answer]

import os
from langchain.agents import create_agent
from tools import check_order_status, lookup_refund_policy, log_refund_decision

agent = create_agent(
    model=os.environ["MODEL_ID"],
    tools=[check_order_status, lookup_refund_policy, log_refund_decision],
    system_prompt=(
        "You are a refund assistant. Check the order, apply policy, decide "
        "refund/escalate/deny, draft a short customer response, and log it."
    ),
)

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "Order R-1001 arrived damaged. Can I get a refund?"
    }]
})

Strengths: simple to build, easy to explain, low ceremony, good for short workflows. Limits: the loop can get messy when the task requires many steps, lots of context, durable artifacts, or specialist subtasks. Best fit: small support actions, simple policy checks, internal copilots, and workflows where each request finishes quickly.

Deep Agent approach

Deep Agents use the same basic idea of a model plus tools, but package it in a more production-oriented harness. The agent can plan work, manage longer context, use files or artifacts, delegate to subagents, and run more complex tasks without forcing every intermediate result into one conversation thread.

flowchart LR
    A[Customer message] --> B[Deep Agent supervisor]
    B --> C[Plan / todos]
    B --> D[check_order_status]
    B --> E[Policy reviewer subagent]
    E --> F[lookup_refund_policy]
    B --> G[Working files / decision note]
    B --> H[Response writer subagent]
    B --> I[log_refund_decision]
    I --> J[Final answer + audit trail]

import os
from deepagents import create_deep_agent
from tools import check_order_status, lookup_refund_policy, log_refund_decision

subagents = [{
    "name": "policy-reviewer",
    "description": "Checks refund policy and returns a decision recommendation.",
    "system_prompt": "Use lookup_refund_policy. Return decision, policy_code, rationale.",
    "tools": [lookup_refund_policy],
}]

agent = create_deep_agent(
    model=os.environ["MODEL_ID"],
    tools=[check_order_status, lookup_refund_policy, log_refund_decision],
    system_prompt=(
        "You are a refund operations agent. Plan, verify the order, apply policy, "
        "draft a customer response, log the decision, and keep an audit note."
    ),
    subagents=subagents,
)

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "Order R-1001 arrived damaged. Can I get a refund?"
    }]
})

Strengths: better for multi-step work, exceptions, auditability, context isolation, and specialist review. Limits: more moving parts, more latency, more things to test, and more design decisions. Best fit: refund operations with edge cases, regulated support, high-value orders, investigations, or workflows that produce durable notes and handoffs.

Difference visualization

flowchart TB
    subgraph R[ReAct]
        R1[User request] --> R2[Single model loop]
        R2 --> R3[Immediate tool call]
        R3 --> R2
        R2 --> R4[Final response]
    end

    subgraph D[Deep Agent]
        D1[User request] --> D2[Plan]
        D2 --> D3[Supervisor]
        D3 --> D4[Specialized subagent]
        D3 --> D5[State / files / artifacts]
        D3 --> D6[Tool calls]
        D4 --> D3
        D5 --> D3
        D6 --> D3
        D3 --> D7[Final response + audit trail]
    end

Evaluation strategy

Evaluate both systems the same way. A non-engineer-friendly way to read evals is: "Did it make the right decision, follow policy, use the right systems, write a usable customer reply, and escalate when risk was present?"

Test	What it checks
Correctness	Did the assistant choose refund, deny, or escalate correctly?
Policy compliance	Did the decision match the refund rule that applies?
Tool-use accuracy	Did it check order status, check policy, and log the result?
Response quality	Is the customer message clear, brief, and not full of internal details?
Escalation safety	Did risky cases, such as chargebacks or missing orders, go to a human?

Sample cases:

Case	Situation	Expected
damaged_within_window	Delivered 7 days ago, damaged item	refund
late_change_of_mind	Delivered 45 days ago, changed mind	deny
lost_shipment	Shipment lost	refund
open_chargeback	Wrong item plus open payment dispute	escalate
missing_order	Order cannot be found	escalate

def grade_case(case, result):
    trace_tools = {step["tool"] for step in result.get("tool_trace", [])}
    return {
        "correctness": result["decision"] == case["expected_decision"],
        "policy_compliance": result["policy_code"] == case["expected_policy_code"],
        "tool_use_accuracy": {
            "check_order_status",
            "lookup_refund_policy",
            "log_refund_decision",
        }.issubset(trace_tools),
        "response_quality": len(result["customer_response"].split()) >= 18,
        "escalation_safety": (
            case["expected_decision"] != "escalate"
            or result["decision"] == "escalate"
        ),
    }

In the included local evals, both samples score 5/5 on the small deterministic dataset. That does not prove production readiness. It proves the sample policy path works and gives you a starting harness. In production, add more real cases, adversarial messages, policy edge cases, and human review of failed outputs.

GitHub Code Repos

Each contains README.md, requirements.txt, agent.py, tools.py, evals.py, and sample_cases.json. The default eval path runs without API keys. Set USE_LLM=1 and MODEL_ID to exercise the real LangChain or Deep Agents path.

Decision guide

Choice	Use when	Avoid when
ReAct-style LangChain agent	The workflow is short, policy is clear, tools are few, and speed matters.	The task needs durable artifacts, many exceptions, or specialist sub-workflows.
Deep Agent	The workflow needs planning, subagents, longer context, audit notes, or handoffs.	The job is a simple lookup-and-reply task where extra orchestration adds cost without value.

Final recommendation

Teams starting today should begin with a ReAct-style LangChain agent for the narrow refund path, then move to a Deep Agent when operational complexity shows up: chargebacks, high-value approvals, policy exceptions, audit trails, or multi-team handoffs. Keep the eval dataset constant across both. That makes the architecture decision practical instead of theoretical.

Source notes

LangChain and Deep Agents APIs evolve, so verify package versions against official docs before production use. The current examples here follow the official LangChain agents docs, LangChain v1 migration notes, Deep Agents overview, Deep Agents quickstart, and Deep Agents subagents documentation:

https://docs.langchain.com/oss/python/langchain/agents
https://docs.langchain.com/oss/python/migrate/langchain-v1
https://docs.langchain.com/oss/python/deepagents/overview
https://docs.langchain.com/oss/python/deepagents/quickstart
https://docs.langchain.com/oss/python/deepagents/subagents

DORA is Dead: Why 2026 Demands "AI Attribution Layers" in the SDLC

2026-04-13T00:00:00-04:00

DORA is Dead: Why 2026 Demands "AI Attribution Layers" in the SDLC

In the third quarter of 2025, a fintech unicorn we’ll call "Astra" achieved the impossible. Their engineering dashboard was a sea of emerald green. According to traditional DORA (DevOps Research and Assessment) metrics, Astra’s platform team was "Elite." Their Deployment Frequency had tripled, and their Lead Time for Changes had shrunk to under three hours. On paper, they were the fastest engineering organization in the Valley.

By Q1 2026, Astra was in receivership.

What happened? The metrics didn't lie, but they no longer measured reality. Astra’s engineers had leaned so heavily into autonomous coding agents that they were shipping 400% more code than the previous year. However, that code was a "Frankenstein" of AI-generated blocks with no human lineage. The "Elite" velocity was actually a high-speed collision with technical debt. The system didn’t break because of slow deployments; it broke because the human review capacity could not keep pace with the AI-driven firehose.

The factory floor is now automated, but the robots are outrunning the conveyor belt. In 2026, DORA metrics—the gold standard of the last decade—have officially become vanity metrics. If you are still managing your VPs of Engineering based on Deployment Frequency alone, you aren't leading; you’re observing a crash in slow motion. We need a new architectural standard: The AI Attribution Layer.

The Goodhart’s Law of AI

Why Optimizing for "Velocity" Leads to "Garbage In, Garbage Out"

The fundamental flaw in modern SDLC management is a classic case of Goodhart’s Law: "When a measure becomes a target, it ceases to be a good measure." For years, we targeted PR throughput as a proxy for value. AI has broken that proxy.

According to recent DX Tooling Benchmarks, Cursor and GitHub Copilot users saw a staggering 46% jump in PR throughput (moving from a median of 2.8 to 4.1 PRs) between Q4 2025 and Q1 2026. On the surface, this looks like a productivity miracle. In reality, it is the Throughput Illusion. When code generation becomes essentially "free" via LLMs, the cost of authoring drops to near zero, but the cost of maintaining and validating scales exponentially. If your team is shipping 4.1 PRs per week but 90% of those are agent-authored, your "Deployment Frequency" is no longer measuring team health—it’s measuring how often your engineers hit Cmd+K.

We are seeing a Quality Crisis that traditional DORA metrics are blind to. Netcorp and GitClear’s 2026 research reveals that while 41% of all code is now AI-generated, the code churn rate—the percentage of code revised or deleted within two weeks of being pushed—has spiked to 5.7%. Compare that to the 3.1% baseline in 2020. We are moving faster, yes, but we are running in circles, constantly refactoring the hallucinatory output of last week's "Elite" sprint.

Defining the AI Attribution Layer

The Digital Signature for the Modern SDLC

To regain control, CTOs must implement an AI Attribution Layer (AIAL). Think of this as a "Digital Signature" for every line of code. Just as git blame allows us to identify which human modified a file, the Attribution Layer identifies the provenance of the logic.

An effective AIAL tracks three critical new KPIs that replace the aging DORA pillars:

AI Code Share (ACS): The percentage of a PR authored by an LLM versus a human. In 2026, a "High-Performing Team" isn't the one with the highest ACS; it’s the one with the most stable ACS. If a mission-critical service suddenly jumps from 20% to 80% AI authorship, that is a red flag for architectural integrity.
Agentic Churn: This measures how often AI-generated code is rewritten by humans. If your AI-generated blocks have a 15% churn rate while human blocks stay at 3%, your "AI productivity gain" is a net negative once you factor in the Senior Engineer's "Cognitive Tax" for fixing it.
The Review Bottleneck (AI vs. Human Cycle Time): In the DORA era, we measured "Lead Time for Changes" from first commit to production. Today, this is a useless metric because the "authoring" phase is now instant. Lead Time is no longer a measure of CI/CD efficiency; it is a measure of Senior Engineer availability. Humans have become the "manual validators" for an AI firehose. If your lead time is increasing while your throughput is also increasing, your senior talent is drowning.

The Seniority Divide

Knowledge Retention as a Strategic Risk

The most dangerous side effect of the AI-accelerated SDLC is the "Hollow Middle." We are seeing a widening gap between the "Elite" architects who can orchestrate agents and the "Junior" developers who have become glorified copy-pasting clerks.

The Uvik/Stack Overflow 2025/2026 surveys highlight a staggering Trust Gap: despite AI being used in nearly every IDE, developer trust in AI accuracy has plummeted to 29%. This creates a paradox:

Seniors spend their days debugging AI "hallucinations" rather than mentoring.
Juniors lack the "struggle time" necessary to build mental models of the codebase because the AI provides the answer before they've even framed the question.

This is a knowledge-retention risk. If your AI-generated code share is high and your team turnover is standard, you are losing the "tribal knowledge" of why things work. The AI knows what to write, but it doesn't understand the "Why" of your specific business logic. If your senior staff leaves, you are left with a codebase that no living human actually understands.

The 2026 Playbook

Actionable Steps for Engineering Directors

If you want to survive the "Post-DORA" world, you must stop managing by the dashboard and start managing by the Attribution Layer. Here is your 2026 implementation plan:

1. Mandatory PR Metadata Tags

Implement automated tagging in your CI/CD pipeline. Every PR must include a metadata header indicating the tool used for generation.

Example Tags: author: human, co-author: claude-4, agent: aider-v5. This allows you to calculate the
Cost per Feature with nuance. If a feature took two days but was 90% AI-generated, its "cost" is actually higher in terms of long-term maintenance than a three-day human-authored feature.

2. Risk-Weighted Review Pipelines

Track the ratio of Lines of Code (LOC) Changed vs. Review Time. If your AI is outputting 1,000 lines of code and your seniors are approving them in 5 minutes, you aren't "Agile"—you’re compromised. Establish a "Brake Limit": if AI Code Share exceeds 60%, the PR requires two senior human reviewers and a mandatory "Interactive Loom Review" where the author explains the logic.

3. The Value-to-Churn Ratio (VCR)

Replace your velocity metrics with the VCR. This formula balances the volume of output against the stability of the code provenance:

VCR = (Features Delivered X (1 - AI Code Share}) / Agentic Churn Rate

A high VCR indicates a team that is using AI as an accelerant for human-led architecture, rather than a replacement for it.

Conclusion: Orchestration is the New Leadership

The era of the "10x Developer" is over; we are now in the era of the 100x Orchestrator. But with great power comes a massive decline in visibility.

DORA metrics were designed for a world where humans wrote code at the speed of thought. That world is gone. Today, we are managing a hybrid workforce of biological and synthetic intelligence. To treat them as the same is a failure of leadership.

The shift from DORA to the AI Attribution Layer isn't just a technical change—it’s a philosophical one. It is the move from measuring Activity to measuring Accountability. As a Director or CTO, your job is no longer to ensure the factory is running fast. Your job is to ensure that when the robots finish their shift, a human still knows how to find the "Off" switch.

DORA is dead. Long live the Attribution Layer.

How Engineering Leaders Can Raise Internal Comms Quality with Anthropic Skills

2026-04-13T00:00:00-04:00

How Engineering Leaders Can Raise Internal Comms Quality with Anthropic Skills

Engineering leaders rarely struggle because writing is impossible. They struggle because internal communication keeps arriving as a tax. The weekly exec update has to be reconstructed from Slack threads, the incident summary sounds different every time depending on who was on call, and a roadmap pause that should take fifteen minutes becomes three rounds of editing because nobody agrees on tone or structure.

That is the opening for Anthropic Skills, and specifically the public internal-comms skill. Anthropic’s public skills repository describes Skills as folders of instructions, scripts, and resources that Claude loads for specialized tasks. The internal-comms skill is one of those packaged patterns: identify the communication type, load the matching guideline from examples/, and follow it. The point is not to replace judgment. It is to give the assistant a reusable house style for recurring internal writing.

The Job-to-Be-Done

Internal comms failures impose real operating cost on engineering orgs. They create misalignment when the same migration or reliability issue gets described differently by PM, engineering, and leadership. They create duplicate meetings when weak written artifacts force teams to restate context in every sync. They create slow decisions when a note mixes progress, risks, blockers, and opinion so badly that nobody knows what needs approval.

Weekly narrative stitching across Jira, Slack, dashboards, and on-call signals
Incident and reliability communication where tone and precision matter
Change management notes for pauses, migrations, SLO tradeoffs, and security work

What the `internal-comms` Skill Is, and Isn’t

The public internal-comms skill covers recurring formats such as 3P updates, company newsletters, FAQ responses, status reports, leadership updates, project updates, and incident reports. Its workflow is explicit:

Identify the communication type.
Load the corresponding guideline from examples/.
Follow that file’s instructions for structure, tone, and information gathering.

The public examples are concrete. examples/3p-updates.md defines a short, matter-of-fact Progress, Plans, Problems update meant to be readable in roughly 30 to 60 seconds and asks for metrics where possible. examples/company-newsletter.md pushes toward short bullets and company-wide relevance. examples/faq-answers.md keeps answers brief and grounded in official communications. examples/general-comms.md handles requests that do not fit a preset.

That makes the skill useful because it encodes two things most engineering orgs otherwise leave implicit:

The house style for recurring communication artifacts
The default information model for each artifact

What it is not: a substitute for incident command or a way to skip leadership review. The skill standardizes drafting. Humans still decide what is material and what needs different language for customers, executives, or the broader engineering org.

Operationally, leaders can keep a skill like this wherever their team can version and improve it: a shared team repo next to operating docs, or a personal skills area before socializing it more broadly. The point is that the SKILL.md and example guides become editable working agreements rather than folklore.

Sidebar: Sample starter phrases

“Use the internal-comms skill to draft a 3P for the Core Platform team for April 7 to April 13. Separate shipped work from next week’s priorities and include one metric if supported.”

“Use the internal-comms skill to draft an executive incident summary from these notes. Keep it factual, no blame, and split internal actions from customer-facing comms.”

“Use the internal-comms skill to turn this migration thread into a cross-team FAQ for PM and support. Keep answers under two sentences and add runbook link placeholders.”

Five Playbooks to Try This Week

1. Weekly engineering 3P for execs

Scenario: Maya Chen, Director of Engineering for Core Platform, needs a Monday morning update for the CTO and product leadership.

What you paste or say to the assistant:
“Use the internal-comms skill and draft a 3P for the Core Platform team covering April 7 to April 13. Use these notes: Jira velocity was 42 completed issues versus 35 planned; API gateway p95 latency improved from 410ms to 320ms after cache tuning; on-call saw 3 Sev-2 pages tied to one noisy dependency; security review for service-to-service auth is complete; next week we plan to finish canary rollout for the new rate limiter and start the PostgreSQL failover game day. Keep it to a 30 to 60 second read. Separate Plans from Progress.”

What good output looks like:
A tight update with clearly separated Progress, Plans, and Problems. It includes at least one metric and lets an executive grasp team health quickly.

One guardrail:
Do not let Problems become a disguised status dump. Only include issues that materially slow execution or change leadership attention.

2. Post-incident executive summary

Scenario: After a payments outage, Ravi Nair, VP Engineering, needs an internal executive summary within an hour of service restoration.

What you paste or say to the assistant:
“Use the internal-comms skill to draft an executive incident summary for today’s payments outage. Include timeline, customer impact, provisional root cause, remediation completed, and what communication goes to customers versus internal teams. Keep the tone factual and no-blame. Notes: incident started 09:14 PT, customer impact was 18% checkout failure for US web for 27 minutes, rollback completed 09:41 PT, suspected trigger is bad connection pool settings in the new billing worker, permanent fix is still under investigation.”

What good output looks like:
A short summary with precise timestamps, impact stated in business terms, clear separation between known facts and provisional findings, and an explicit split between customer-facing communication and internal follow-up.

One guardrail:
Label anything unconfirmed as provisional. Incident summaries become source material later; false certainty is expensive.

3. “Why we’re pausing initiative X”

Scenario: Elena Brooks, Staff+ leader for Developer Experience, needs a leadership update explaining why the team is pausing self-serve environment previews.

What you paste or say to the assistant:
“Use the internal-comms skill to draft a leadership update explaining why we are pausing the self-serve preview environments initiative for one quarter. Audience is engineering managers and product leads. The reasons are release regression rates, open auth hardening work, and platform team capacity. Preempt likely objections in FAQ style. Notes: mobile and web release regressions increased 22% quarter over quarter, two security review items are blocking broader rollout, and the same team owns CI stability.”

What good output looks like:
A concise note that frames the pause as a tradeoff, not a retreat, then answers obvious follow-up questions such as “Is the initiative cancelled?” and “What has to be true to restart?”

One guardrail:
Name the tradeoff directly. If the real reason is capacity plus risk reduction, do not hide it behind vague language like “strategic reprioritization.”

4. Org newsletter blurb

Scenario: Nisha Patel, VP of Engineering, contributes a short blurb to the monthly company newsletter.

What you paste or say to the assistant:
“Use the internal-comms skill to draft a short engineering section for the company newsletter. Include shipped capabilities, hiring, and one learned lesson. Use a neutral company voice. Notes: we shipped audit log export for enterprise admins, completed staged rollout of the event ingestion rewrite, hired two senior infrastructure engineers in Dublin, and learned during the Kafka migration that runbook ownership was too diffuse.”

What good output looks like:
A clean set of short bullets in “we” voice, focused on company-relevant milestones rather than team trivia. The learned lesson sounds sober and useful.

One guardrail:
Do not turn the newsletter into a team update. If a detail only matters to one engineering subgroup, it probably belongs in a 3P, not a company newsletter.

5. Cross-team FAQ after a platform migration

Scenario: Jordan Kim, Director of Platform Engineering, has finished a customer identity migration.

What you paste or say to the assistant:
“Use the internal-comms skill to draft a cross-team FAQ for PMs and support after the customer identity migration. Keep answers short, add placeholders for runbook links, and focus on what changed, what did not, and where issues should be routed. Questions to cover: Are session timeouts different? What errors should support expect during cutover? When should PMs escalate login issues? What dashboards show migration health?”

What good output looks like:
Short question-and-answer pairs that reduce repeat explanations, point to authoritative runbooks, and distinguish product behavior changes from support procedures.

One guardrail:
Anchor answers to official sources. If an answer still depends on ongoing validation, say so and point readers to the owning team.

The Rollout Recipe for Leaders

Do not start by trying to standardize every engineering artifact at once. Start with one high-frequency format, usually the weekly 3P. It has the highest repetition and the clearest success criteria.

Then iterate the skill with real redlines. When your CTO rewrites a Progress line to be more metric-driven, or your incident commander deletes speculative language, that is not noise. That is the training signal for the guideline file. Capture those edits in the examples so the next draft starts closer to the mark.

After the weekly update feels reliable, expand to incident summaries and FAQs. Communication quality there directly affects decision speed and cross-functional load.

If a guideline has been bypassed three times in a month, update it. A stale skill becomes process theater.

Risks and Hygiene

PII and secrets in prompts: scrub customer identifiers, credentials, and sensitive legal language before pasting raw notes into the assistant.
Over-standardization: if every update sounds identical, the org will stop reading. Keep the structure stable, but let material differences in risk, uncertainty, and tone show through.
Lost nuance in incidents: short formats are useful, but they can flatten ambiguity. Incident summaries should separate confirmed facts, hypotheses, and follow-up actions.
Drafts mistaken for final: anything going to executives, customers, or the full engineering org should still get a human pass for accuracy, tone, and audience fit.

The review question is not “Did the assistant write this?” It is “Would I stand behind this note in a room where people can ask hard questions?”

Try Tomorrow

Pick one artifact you already produce every week, preferably the exec 3P, and define the exact structure you want repeated.
Save one good redlined example and one bad example, then update the guideline so the difference is explicit.
Run the next draft through the skill, edit it like an operator, and feed those edits back into the examples before the week ends.

References

The Paper Architect: Why Writing is the Highest-Leverage Mental Software You’re Not Updating

2026-04-11T00:00:00-04:00

The Paper Architect: Why Writing is the Highest-Leverage Mental Software You’re Not Updating

We are currently living through a crisis of cognitive overhead. Every day, the average human processes the equivalent of 34 gigabytes of data—enough to crash a laptop within a week if it weren't constantly being overwritten. Our brains, magnificent as they are, were never evolved to be storage units for endless to-do lists, unresolved traumas, and the paralyzing noise of the digital age. They were evolved to be processors.

When we fail to "export" our internal dialogue, we experience a specific kind of mental friction: the feeling of being "stuck," "burnt out," or "emotionally heavy." This is not a character flaw. It is a system failure.

The most effective, lowest-cost, and highest-leverage tool to fix this system isn't a new app or a pharmaceutical intervention. It is the ancient, deceptively simple act of putting ink to paper. To become a Paper Architect is to stop being a victim of your thoughts and start being the designer of your internal landscape.

1. The Research Foundation: The Biology of the Written Word

The idea that writing is "good for you" is often dismissed as soft advice. However, the hard science suggests that writing acts as a biological "force multiplier" for the human immune and nervous systems.

The Pennebaker Effect: Writing as Medicine

In the 1980s, Dr. James Pennebaker, a social psychologist at the University of Texas at Austin, conducted a landmark study that changed our understanding of the mind-body connection. He asked students to write for just 15 minutes a day for four consecutive days about a traumatic or stressful experience.

The results, published in his research on Expressive Writing, were staggering: those who engaged in the practice showed significantly improved immune function, including higher T-lymphocyte counts, and made fewer visits to the doctor in the following months. As noted by the American Psychological Association, translating an experience into language forces the brain to organize the event, which reduces the physiological stress of "holding" the memory in an unstructured, chaotic state.

The Science of Gratitude and the Reward System

While Pennebaker focused on the release of the negative, researchers like Robert Emmons and the team at the Greater Good Science Center have focused on the "up-regulation" of the positive.

Gratitude journaling isn't just about "thinking happy thoughts." It is a targeted exercise in neuroplasticity. In the seminal study "Counting Blessings Versus Burdens", Dr. Emmons found that people who wrote about things they were grateful for felt better about their lives as a whole and were more optimistic about the future. This practice stimulates the hypothalamus, which regulates stress, and floods the neural pathways with dopamine.

Cognitive Offloading and the Zeigarnik Effect

Have you ever been unable to sleep because you were mentally rehearsing a task you hadn't finished? That is the Zeigarnik Effect: the tendency of the brain to keep "open loops" active in our working memory until they are completed.

Writing things down is a form of Cognitive Offloading. By moving information from the internal "RAM" of your brain to the external "Hard Drive" of the page, you free up processing power. This is further bolstered by the Generation Effect, a phenomenon discovered by Slamecka and Graf (1978) where the brain remembers information significantly better when it has been actively produced (written) rather than just passively read.

[Visual Suggestion 1: A Comparison Chart] Create a table showing "The Mental Load Cost." Compare 'Internal Processing' (High Cortisol, High Cognitive Load, Fragmented Focus) vs. 'Written Processing' (Lowered Cortisol, Externalized Memory, Narrative Cohesion).

2. The Three-Pillar Framework

To master the art of the Paper Architect, you must understand that not all writing serves the same purpose. You need three distinct modalities to navigate the complexities of modern life.

Pillar I: The Emotional Release (Expressive Writing)

The Goal: To vent the "pressure cooker" of the mind when feeling overwhelmed, angry, or anxious.

When the emotional "noise" becomes too loud to ignore, trying to think logically is like trying to fix a jet engine while it’s on fire. You must first extinguish the flame. This is where Free Flow writing comes in.

The Instruction: Set a timer for 10 to 15 minutes. Start writing. Do not worry about grammar, punctuation, or whether you sound like a "good person." This is a "brain dump." If you are angry, write it in jagged, messy letters. If you are grieving, let the words trail off. The goal is not to produce a masterpiece; the goal is to spend the emotional energy. Once the energy is on the page, the physical body can finally begin to down-regulate from a "fight or flight" state into a "rest and digest" state.

Pillar II: The Numbness Antidote (Gratitude Writing)

The Goal: To combat burnout, apathy, and the "gray" feeling of modern existence.

Burnout is often a result of Hedonic Adaptation—we become so used to our surroundings that we stop seeing the value in them. Traditional gratitude lists (e.g., "I am thankful for my dog") often fail because they are too abstract.

The Instruction: Instead of a list, perform a Sensory Deep Dive. Pick one thing and describe it using all five senses.

Instead of "I like my morning coffee," try: "The way the steam feels against my cold nose, the bitter-dark scent of the roasted beans, the weight of the ceramic mug that warms my palms, and the first sharp, hot sip that signals the start of my day." This level of detail forces the brain to re-engage with reality, breaking the cycle of apathy and reconnecting the soul to the present moment.

Pillar III: The Conflict Resolver (Iterative Reflection)

The Goal: To navigate interpersonal friction or professional confusion with surgical precision.

Most people "process" conflict by ruminating—replaying the argument in their head until they are the hero and the other person is the villain. This solves nothing. To solve a conflict, you must move from reacting to iterating.

The Instruction: Use this 3-step structured template:

The Playback: Write down exactly what happened using only objective facts. (e.g., "He said X, I said Y, the meeting ended early.") No interpretations allowed.
The Pivot: Ask yourself, "If I were the most emotionally mature version of myself, what would I have done differently?" This shifts you from a defensive posture to a growth posture.
The Micro-Action: What is one small, immediate step you can take to improve the outcome? This could be a text, an apology, or a decision to let it go. Action is the ultimate antidote to anxiety.

3. Why the Hand-to-Brain Connection Matters

In an era of AI and voice-to-text, you might wonder: Does it have to be a pen?

While typing is faster, the neurological "bang for your buck" is higher with handwriting. Functional MRI (fMRI) scans show that handwriting engages the brain’s "Reading Circuit" more deeply than typing. The tactile sensation of the pen, the varying pressure, and the slower pace force a deliberate "pacing" of thought. You cannot write as fast as you think, and that is precisely the point. The "drag" of the pen allows your logic to catch up with your emotions.

4. The Architecture of a New Life

When you begin to use these three pillars, something subtle happens. You stop being a person who is "having a bad day" and start being a person who is "observing a challenging set of circumstances."

Writing creates Psychological Distance. By placing your thoughts on a physical piece of paper, you create a space between the observer (you) and the observed (the thought). In that space lies your freedom. You realize that you are not your thoughts; you are the architect who can rearrange them.

Your 7-Day "Paper Architect" Challenge

Knowledge without application is just "intellectual entertainment." To see the science work in your own biology, I challenge you to test one pillar per day for the next week, based on your current emotional state.

Days 1-2 (The Foundation): Spend 10 minutes on a Free Flow brain dump. Clear the pipes. Get the "noise" out of your system.
Days 3-4 (The Calibration): Perform a Sensory Gratitude deep dive each morning. Find the texture in your life.
Days 5-6 (The Strategy): Identify one lingering "open loop" or conflict in your life. Apply the 3-Step Conflict Resolver template.
Day 7 (The Reflection): Read back through what you wrote. Notice the patterns. Notice the shifts in your heart rate and your perspective.

The paper is waiting. It is the cheapest therapist, the most loyal confidant, and the most efficient strategist you will ever meet. It’s time to start building.

Beyond the "Job Apocalypse": How AI is Fueling a Net-Positive Labor Revolution

2026-04-10T00:00:00-04:00

Beyond the "Job Apocalypse": How AI is Fueling a Net-Positive Labor Revolution

The year is 2026, and the "Great Automation Anxiety" that dominated headlines two years ago has begun to yield to a more complex reality. For years, the narrative was binary: you were either a human worker or you were replaced. But as the dust settles, we aren't looking at mass unemployment. Instead, we are witnessing the refactoring of the global labor market.

We are moving past the "Job Apocalypse" and into the era of the "Supercharged Professional." The data is clear: AI isn't shrinking the pie; it’s changing the recipe.

1. The Refactoring of Labor: Replacing Tasks, Not People

A job is a collection of tasks. AI excels at automating the routine, but struggles with the holistic "job." By offloading the "drudge work," we haven't eliminated the worker; we’ve elevated the role.

Case Study: In 2024, skeptics predicted the end of junior associates in law. Today, Junior Lawyers have transitioned from spending 60 hours a week on manual document review to strategic AI-assisted litigation. They use AI to parse millions of documents, allowing them to focus on crafting nuanced legal theories—a task requiring human intuition.
The Transition: This shift isn't instantaneous. It involves a "Productivity J-Curve," where companies initially see a performance dip while they restructure workflows and address "organizational debt" before seeing massive gains (Medium/Soul-Guided Systems).

2. The New Workforce Titans: A Net-Positive Reality

The numbers tell a story of massive net growth. According to the World Economic Forum (WEF) Future of Jobs Report 2025, shifting global trends will generate significant opportunities by 2030: * Displaced Jobs: ~92 million roles globally. * New Roles Created: ~170 million roles. * Net Gain: 78 million new jobs.

This growth is reflected in hiring trends. In the 2024/2025 window, AI-related hiring (~120,000 roles) significantly outpaced confirmed AI-driven layoffs (~13,000 roles) (High5Test/Fortune Data).

3. Productivity as a Growth Engine

One of the most persistent myths is that productivity gains only benefit the "bottom line." However, PwC’s 2025 Global AI Jobs Barometer shows that industries with high AI exposure saw 27% growth in revenue per employee. When a company becomes 27% more efficient, it often reinvests that capital into new product lines and departments, such as AI Governance and AI SecOps, which didn't exist three years ago.

4. The "Rehire" Phenomenon: The Empathy Gap

In the rush to automate, several firms over-leveraged AI and cut middle-management and service staff. They are now learning a hard lesson: AI lacks "thick" empathy and complex moral judgment.

Gartner predicts that by 2027, 50% of companies that cut staff due to AI will rehire humans for "refactored" roles. These companies found that while AI can solve technical problems, it cannot de-escalate a frustrated client or navigate high-stakes negotiations. The new hires are returning as Human-AI Orchestrators, providing the "human touch" that maintains brand trust.

5. The Human Element & The Wage Premium

In an economy saturated with automated logic, human-centric "soft skills" have become a luxury good. There is a massive Wage Premium for those who can bridge the gap.

According to PwC's 2025 findings: * Jobs requiring advanced AI skills carry a 56% wage premium. * The half-life of a technical skill has dropped to ~2.5 years, making continuous reskilling the only path to job security.

Key Takeaways

Validation Economy: New regulations (like the EU AI Act) mandate human sign-off on AI outputs, creating a massive need for "Human Validators."
Reskilling is Mandatory: The 78-million job surplus is only accessible to those who actively transition their skills.
The Real Risk: You won't be replaced by AI, but you might be replaced by a human who knows how to use it.

The net-positive revolution isn't coming; it’s already here.

How to embed Mermaid Diagrams in Pelican generated Blog Post

2024-06-04T00:00:00-04:00

How to embed Mermaid Diagrams in Pelican generated Blog Post

Recently, I've come across the need to embed Mermaid diagram in one of my blog post. In this blog post, I wanted to use Mermaid diagram to show various Agile methodologies workflows. I prefer writing my blog posts in Markdown. In case, you are intereseted in learning to setup your own Pelican generated blog that can be hosted using Github pages, checkout my this blog post.

I embeded HTML code in Markdown file as below. This is a two step process:

Import `mermaid` library

In your markdown file, import mermaid library within <script> tags.

<script type="module">import mermaid from 'https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs'; </script>

Initialize the library:

mermaid.initialize({ startOnLoad: true });

Wrap `mermaid` code in `<pre>` tag

<pre class="mermaid">
graph TD;
    A[Product Backlog] --> B[Sprint Planning];
    B --> C[Sprint Backlog];
    C --> D[Development];
    D --> E[Daily Stand-up];
    D --> F[Sprint Review];
    F --> G[Product Increment];
    G --> H[Sprint Retrospective];
    H --> B;
</pre>

Everything all together!

<script type="module"> import mermaid from 'https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs'; mermaid.initialize({ startOnLoad: true }); </script>
<pre class="mermaid">
graph TD;
    A[Product Backlog] --> B[Sprint Planning];
    B --> C[Sprint Backlog];
    C --> D[Development];
    D --> E[Daily Stand-up];
    D --> F[Sprint Review];
    F --> G[Product Increment];
    G --> H[Sprint Retrospective];
    H --> B;
</pre>

What makes Scrumban an effective Agile framework

2024-06-03T00:00:00-04:00

What is Scrumban

Agile methodologies have revolutionized software development by promoting flexibility, continuous improvement, and collaboration. Among the many Agile frameworks, Scrum and Kanban are two of the most widely used agile frameworks. Scrum is known for its structured approach and defined roles, while Kanban emphasizes visualizing workflow and limiting work in progress (WIP). However, a hybrid approach known as Scrumban blends the strengths of both Scrum and Kanban.

In this article, I'll give quick overview of each of the three methodologies and the visual representations of sample workflows followed by the pros and cons of each framework.

What is Scrum

Scrum is a popular Agile framework that structures work in time-boxed iterations called sprints, typically lasting two to four weeks. It revolves around key roles (Product Owner, Scrum Master, Development Team) and ceremonies (Sprint Planning, Daily Stand-up, Sprint Review, and Sprint Retrospective).

Example 1: Banking application project using Scrum

Let's take example of the team that is developing a financial software. This team is tasked with developing a banking application. They chose Scrum to build this new banking application. The project is divided into sprints, each focusing on delivering specific features like account management, transaction processing, and user authentication. Daily stand-ups ensure team alignment, while sprint reviews and retrospectives keep continuous improvement on track.

Sample Scrum Workflow:

graph TD;
    A[Product Backlog] --> B[Sprint Planning];
    B --> C[Sprint Backlog];
    C --> D[Development];
    D --> E[Daily Stand-up];
    D --> F[Sprint Review];
    F --> G[Product Increment];
    G --> H[Sprint Retrospective];
    H --> B;

What is Kanban?

Kanban is a visual workflow management method that helps teams visualize their work, maximize efficiency, and continuously improve. Key elements include visual boards, WIP limits, and a focus on flow rather than time-boxed iterations.

Example 2: Customer support application project using Kanban

Let's take another example of a team developing a customer support application uses Kanban to manage their tasks. They create a Kanban board with columns like Backlog, In Progress, Code Review, Testing, and Done. By limiting the number of tasks in each column, the team ensures a smooth flow of work and quickly addresses bottlenecks.

Sample Kanban workflow:

graph TD;
    A[Backlog] --> B[To Do];
    B --> C[In Progress];
    C --> D[Code Review];
    D --> E[Testing];
    E --> F[Done];

What is Scrumban?

Scrumban is a hybrid Agile methodology that combines the structured approach of Scrum with the flexibility and flow focus of Kanban. It allows teams to leverage the best of both worlds, adapting Scrum practices as needed while maintaining a continuous workflow.

Example 3: An e-commerce application project using Scrumban

Let's take example of a software engineering team working on an e-commerce platform adopts Scrumban to handle frequent changes in requirements and priorities. They use a Kanban board for continuous flow and implement Scrum ceremonies (like sprint planning and retrospectives) to maintain structure and facilitate continuous improvement.

Sample Scrumban Workflow:

graph TD;
    A[Product Backlog] --> B[Sprint Planning];
    B --> C[Sprint Backlog];
    C --> D[Development];
    D --> E[Daily Stand-up];
    D --> F[Code Review];
    F --> G[Testing];
    G --> H[Done];
    D --> I[Sprint Review];
    I --> J[Product Increment];
    J --> K[Sprint Retrospective];
    K --> B;

Why Scrumban is Better

Flexibility and Adaptability

Scrumban offers greater flexibility compared to Scrum, which can be rigid due to its fixed-length sprints and strict role definitions. In contrast, Scrumban allows teams to adjust their processes based on project needs, combining Scrum's iterative approach with Kanban's continuous flow.

Example: In a rapidly changing project, a team can easily adjust their priorities and reassign tasks without waiting for the next sprint, as would be required in Scrum.

Improved Workflow Management

Kanban's emphasis on visualizing work and limiting WIP helps teams identify bottlenecks and streamline processes. Scrumban integrates these principles with Scrum's structure, enhancing overall workflow management.

Example: A team can visualize their tasks on a Kanban board, use WIP limits to maintain a manageable workload, and still hold regular sprint reviews to assess progress and plan next steps.

Better Team Collaboration and Efficiency

By blending Scrum's focus on roles and ceremonies with Kanban's continuous improvement, Scrumban fosters better team collaboration and efficiency. Teams benefit from regular feedback loops and clear communication channels.

Example: Regular stand-ups and retrospectives in Scrumban encourage open communication and continuous improvement, leading to higher team morale and productivity.

Scrum vs Kanban vs Scrumban

Methodology	Pros	Cons
Scrum	- Structured process with clear roles and ceremonies - Promotes regular feedback and continuous improvement - Time-boxed sprints help manage work and deadlines	- Can be inflexible due to fixed-length sprints - Potential for sprint pressure and burnout - Requires strict adherence to Scrum practices
Kanban	- Highly flexible and adaptive to changes - Visualizes workflow, making it easy to identify bottlenecks - Emphasizes continuous improvement and flow	- Lack of structure compared to Scrum - Potential for overload if WIP limits are not managed - Less focus on defined team roles and ceremonies
Scrumban	- Combines flexibility of Kanban with the structure of Scrum - Scales well from small to large teams and projects - Enhances team efficiency and productivity through a hybrid approach	- Can be complex to implement, requiring a deep understanding of both methodologies - Works best with experienced team members - Flexibility can lead to scope creep if not managed properly

Conclusion

Scrumban represents a powerful hybrid approach that leverages the strengths of both Scrum and Kanban, making it an attractive option for software engineering projects. Its flexibility, improved workflow management, and enhanced team collaboration offer significant advantages over pure Scrum or Kanban. While Scrumban's complexity and need for experienced team members can be challenges, its benefits often outweigh these drawbacks, making it a better choice in many scenarios.

References

Liked the article? Let me know with 👏👏👏

Couldn't find a topic of interest? Please leave comments or email me about topics you would like me to write!

Follow me at Medium Follow me at LinkedIn

Creating Effective Tickets to get work done

2024-05-24T00:00:00-04:00

Creating Effective Tickets

These days most of the organizations either small or large rely on Jira, Trello, Asasna or similar tools to plan a features and track their progress to deliver the value to the customers. The various tools refers a 'ticket' with different names. For example, in Jira a ticket is known as 'Issue' whereas a ticket is referred as 'Card' in Trello tool. To keep things simple, I'll use the word 'ticket' to keep this article focused on planning a feature without getting lost in the tooling specific vocabulary. I would use the term 'Creating Ticket' as a tool to break-down a feature into smaller actionable work-items that eventually lead to feature completion and hence delivering value to customers or end-users.

In this article, I'll share my understanding of creating effective ticket, discuss the common ticket types and their main attributes that make a ticket effective.

What is an Effective Ticket?

To put simply, an effective ticket is the one that clearly communicates the necessary information to ensure that the underlying work can be understood and completed efficiently by the assignee.

Types of Ticket

In my experience when planning a feature, there are three types of tickets that can be used to keep things simple while creating just right amount of abstraction when breaking down bigger work items into single actionable units. I frequently use following three types of tickets (or Issue types in Jira tool): 1. Epic (or User Story) 2. Task 3. Bug

An Epic ticket is the one that contains the one slice of functionality towards the big picture feature. Depending on how big a feature is, it can be sliced into multiple Epics. Consider an Epic as the 'brick wall' or 'window' of a lego house. I tend to use Epic and User Story interchangeably based on the size of a feature. Epic is a collection of multiple User Stories. I've used User Story and Sub-Task structure in several projects. However, I found it effective to use Epic to describe a slice of feature and underlying Tasks contributing towards it.

A Task ticket is the smallest actionable unit of work that contributes towards the completion of Epic.

A Bug is self-explanatory. They could the gaps in the expected functionality. There may not be any bugs when starting to build a new feature. However, as soon as a new feature either goes through the testing phase or in end-user hands, its quite normal to discover few expected or un-expected behaviors that needs to be worked on.

Let's take a sample feature of building profile page for account management in a Jira-like web application, to guide the discussion of this article.

This feature "Profile page for account management" can be split into multiple Epics. First, a profile page user-interface design is needed. Second, a functional user-interface that user can interact with. Third, a backend component and API (Application Programming Interface) integration to store the user information for later retrieval. Fourth, quality assurance and testing. Fifth, user documentation and internal documention, etc..etc. There's a good chance that different technical expertise may be needed to execute each of the Epic. For example, designing the Profile page would require UX designing skills, front-end skills like React for implementing the page and backend skills for developing APIs.

Okay, let's go back to identifying top three Epics. For example, these first three Epic could focus on designing progile page and implementing page and developing APIs to make this page functional.

Example Epics could look like below:

Epic #1: Design profile page UI
Epic #2: Develop backend API for profile management
Epic #3: Develop front for profile page

Attributes of an Effective Ticket

An effective ticket is critical for clear communication and successful task completion. Based on my observations, the following four attributes contribute to a well-written ticket that is easily consumable by an assignee and has a high success rate of on-time completion. The following attributes can be used across the Epic, Task and Bug types.

Summary or Title
Description
Acceptance criteria
Verification & Testing (Optional)

Summary (or title)

A concise and descriptive title that summarizes the issue or task. The title should quickly convey the essence of the task to anyone reading it.

Example: "Implement user profile page for account management."

Description

The description should provide detailed information about the ticket, addressing the What, Why, and How of the task. This ensures the assignee understands the scope, importance, and approach to the task. Let's review each of these one by one.

The 'What'

Clearly state what the ticket is about. This helps to set the boundaries and expectations of the task.

Example: "The task is to develop a user profile page where users can view and edit their personal information."

The 'Why'

Explain why this task is important or needed. This provides context and motivation, helping the assignee understand the significance of their work.

Example: "The user profile page will enhance the user experience by allowing users to manage their personal information directly. This feature is critical for user satisfaction and retention."

The 'How'

Outline how the task might be done or suggest solutions. Providing a high-level plan or approach can guide the assignee and ensure alignment with the project’s goals.

Example:

Design the user interface for the profile page.
Develop the backend API to fetch and update user information.
Integrate the frontend with the backend API.
Implement validation for input fields.
Ensure the page is responsive and works on different devices.

Acceptance Criteria

Define what successful completion looks like. Clear acceptance criteria set the standards for when a task can be considered done and help prevent misunderstandings.

Example:

Users can view their personal information (name, email, profile picture, etc.).
Users can edit their personal information and save changes.
Input validation is enforced (e.g., valid email format, mandatory fields).
The page design adheres to the company's UI/UX standards.
The page is responsive and functional across different devices (desktop, tablet, mobile).
All changes are logged and can be audited for security purposes.

Verification & Testing

This section includes verifying what was agreed upon. Although optional, it is highly recommended to outline how the task will be tested to ensure all acceptance criteria are met.

Example: * Conduct usability testing to ensure the profile page is user-friendly. * Perform unit and integration tests to validate that the API functions correctly. * Check input validation rules by entering various data formats. * Test the responsiveness of the page on different devices and screen sizes. * Review the audit logs to ensure all changes are correctly recorded.

Examples of Poorly vs Effectively written Jira Tickets

Before I close, it will be worthwhile to see few examples of each type of ticket discussed so far, comparing poorly written vs well-written

[Example 1] Epic: Develop Profile Page for Account Management

Below is the example of a poorly written vs Effectively written Epic ticket. Usually, poorly written tickets don't have enough information to make the ticket actionable. They don't have clear acceptance criteria or don't have them at all.

Poorly Written Epic Ticket The title and description of this Epic doesn't contain much information about what is being created and why is it needed. The acceptance criteria is very loose since it doesn't provide what's expected from this page. The verification criteria doesn't give details for assignee to verify the completeness and correctness either.

Title: Profile Page

Description: Make a profile page.

Acceptance Criteria:

Page is created.
Users can use it.

Verification and Testing:

Check the page.

Effectively written Epic Ticket In this example of Epic, the description contains the background context of what is being asked for and its justification from end-user perspective. The 'How' part is the overall scope of the feature that needs to be taken into consideration when doing granual level planning and splitting work further into Task type tickets.

Title: Develop Profile Page for Account Management

Description:

What: Create a comprehensive profile page that allows users to view and edit their personal information, change their passwords, and manage other account settings.

Why: Enhance user experience by providing a centralized place for managing account details.

How: Design the UI, develop the backend API, implement the frontend, conduct QA testing, and create documentation.

Acceptance Criteria:

Users can view and edit their personal information.
Users can change their passwords.
Users can manage account settings.
All features are fully tested and documented.

Verification and Testing:

Verify that the profile page meets design specifications.
Test all functionalities to ensure they work as expected.
Review documentation for completeness and accuracy.

[Example 2] Task: Develop Frontend for Profile Page

Below is the example of a Task type of ticket. This Task could further be split into many other Tasks. However, to spare the implementation level details this ticket assumes that developing the Profile page UI in one ticket. The acceptance criteria helps to guide the adherence of the end to end functionality whereas verification and testing ensures the correctness and accuracy achieved.

Poorly Written Task Ticket:

Title: Frontend Profile Page

Description: Make the frontend for the profile page.

Acceptance Criteria: N/A

Verification and Testing: N/A

Effectively written Task Ticket

Title: Implement Frontend for Profile Page

Description:

What: Implement the frontend components for the profile page based on the approved design. Note Add link to approved design or attach screenshot alongwith details on each UI component.

Why: To allow users to interact with the profile page and manage their account information.

How: Use React to build the components, ensure responsiveness, and integrate with the backend API.

Acceptance Criteria:

Frontend components are implemented according to the design.
The profile page is responsive and works on various devices.
The frontend successfully communicates with the backend API.

Verification and Testing:

Verify the layout and styling match the design.
Test the profile page on different devices and screen sizes.
Confirm data is correctly fetched from and sent to the backend API.
Note Add references to front-end testing standards followed in your team

[Example 3] Bug: Error Saving Profile Information

Let's checkout an example of poorly written vs effective bug ticket.

Poorly written Bug Ticket

This ticket doesn't have descriptive title. It's hard to know from title and description about the issue let alone to fix it. Assignee likely will spend extra time to understand what's being asked to fix and where is the error occurring. They will rely on enormous Slack messages exhanges or 1-on-1 conversations just to gather the information on what error is being observed. Even after they fix it, they will likely to remain confused about whether they fixed the originally reported issue.

Title: Error Description: There is an error. Acceptance Criteria: N/A Verification and Testing: N/A

Effectively written Bug Ticket

Title for the ticket is self-explainatory. Assignee immediately knowns which part of the codebase they would like to start on. The description clearly mentions details on error and the severity of issue and its impact on customers. The 'how' piece explicitly sets the expectations for assingee on the action plan. Once issue has been resolved there is a check-list in the form of acceptance criteria before moving this ticket into done column. There are verification and testing steps provided to ensure that the fix has been tested reliably.

Title: Error Saving Profile Information

Description:

What: When attempting to save changes to the profile information, users receive a "500 Internal Server Error" message.

Why: This prevents users from updating their profile information, which impacts user experience and functionality.

How: Investigate the error, identify the root cause, and implement a fix to ensure changes can be saved successfully.

Acceptance Criteria:

The "500 Internal Server Error" is resolved.
Users can successfully save changes to their profile information without errors.
The fix is tested and verified.

Verification and Testing:

Reproduce the error by following the steps provided. Note: Add steps to recreate error
Implement the fix and verify the error is resolved. Note: The fix can be verified against a pre-existing testplan, if any.
Test saving profile information under various conditions to ensure reliability. Note: Various conditions can involve development, sandbox and production environment or load/scale testing.

References

Liked the article? Let me know with 👏👏👏

Couldn't find a topic of interest? Please leave comments or email me about topics you would like me to write!

Follow me at Medium Follow me at LinkedIn

How to avoid burnout as New Manager

2024-05-05T00:00:00-04:00

How to Avoid Burnout as a New Manager

First, I want to thank you for deciding to read this article. Second, I'll make a few assumptions about you that might have led you here.

My first assumption is that you've recently taken up the role of managing people. By "recently," I mean you've been in this role for about 1 to 3 years or less. My second assumption is that you find yourself overwhelmed with new responsibilities.

Understanding the Journey to Burnout

So, you are a new manager? Congratulations! You are now in charge of your team. This could have happened through different paths—perhaps you were promoted within your team, brought in from an internal transfer, or hired directly into this role. Regardless of how you arrived here, the challenges are often similar.

What might have led you to this phase of your career? One of the reason is that you are likely trying to balance the role of an individual contributor while also managing and being responsible for others' work. By the way, the word 'balance' carries the subtle in-built stress. There's always pressure whenever you are carrying out the act of balance.

Recognizing Burnout

It's easy to get trapped in trying to prove your worth by burning the candle at both ends, but this is not sustainable. While delivering or overachieving in the first few years can be rewarding, it's crucial to develop skills that will help you grow into a senior leader while keeping your life enjoyable both at work and outside of it.

Here are some signs that you might be experiencing burnout or are on the verge of it:

Eagerly Waiting for Weekends: If you find yourself constantly counting down the days to the weekend, it might be a sign of burnout.
Monday Blues Start Sunday Afternoon: Feeling anxious or stressed about the upcoming workweek on Sunday afternoon is another indicator.
Low Energy and Dreading the Day Ahead: Consistently feeling drained and apprehensive about your daily tasks is a red flag.
Feeling Overwhelmed and Out of Control: If your workload feels unmanageable and you can't seem to get on top of things, burnout might be looming.

Strategies to Combat Burnout

Now that you've identified potential burnout, let's talk about addressing it and what you can do to mitigate it.

Set Healthy Boundaries

Time-Block for Rest: Dedicate time blocks where you do not think about work. Your brain needs a break from a single type of activity to recharge effectively.

Rest Up!

Take Breaks Instead of Quitting: "If you get tired, learn to rest, not quit." - Banksy. Make sure to rest adequately, both during the day and with a full night's sleep.

Do Something You Love – Outside of Your Job

Pursue Hobbies: Engage in activities you enjoy outside of work. This could be anything from reading, playing a sport, or any other hobby that brings you joy.

Be Practical

Manageable Workload: Only take on tasks you can realistically accomplish in a day. Break larger projects into smaller, more manageable tasks.
Structured Schedule: Calendar your work schedule, including breaks. Use tools like Google Calendar to set reminders for breaks and to manage your time efficiently.

Ground Yourself

Nature Walks: Spend time walking in nature or just outside your office. Even a brief stroll can rejuvenate your mind.
Doodle or Scribble: Engage in small, creative activities like doodling between meetings to give your brain a short, enjoyable break.

Embrace Context Changes

Mindful Transitions: Be mindful of the transition from one meeting to another. Avoid back-to-back meetings when possible and allow yourself time to shift gears.
Move Around: Take small breaks to move around between meetings. A quick stretch or walk can help reset your mind.

Intentional Pauses

Pause and Reevaluate: When feeling overwhelmed, take a moment to pause and reassess your priorities. This helps in regaining control and perspective.

Believe in Yourself

Confidence in Your Skills: Remind yourself of your capabilities and why you were chosen for this role. Trust in your skill set and your ability to grow and succeed as a manager.

By incorporating these strategies into your daily routine, you can mitigate the risk of burnout and create a more fulfilling work-life experience.

__Liked the article? Let me know with 👏👏👏

Couldn't find a topic of interest? Please leave comments or email me about topics you would like me to write!

Follow me at Medium Follow me at LinkedIn

Vim Quick References

2022-09-07T00:00:00-04:00

This article is a quick getting started guide to Vim editor commands. Vim editor is an improved version of classic Vi editor, hence named 'Vi Improved' or Vim in short.

Note: I'm using macOS Terminal to run vim editor.

Installing Vim Editor (macOS)

You can download Vim editor on macOS using Homebrew package manager.

brew install vim

Verify the installation of Vim editor by checking its version as below:

vim --version

The above command will print the current version of Vim editor as below:

% vim --version
VIM - Vi IMproved 8.2 (2019 Dec 12, compiled Nov 13 2021 05:05:08)
macOS version - arm64

Opening Vim editor

You can start opening the editor by using vim followed by the file name as below:

vim test_file

The above command will open the test_file in vim editor. Press i to change to insert mode to start writing into file.

Modes of Vim

There are mainly three modes in Vim editor:

Normal mode: This is the mode Vim editor opens in. If you try to type in this mode, you would not be able to. That may leave you in bit confusion on how to edit this file. You would need to change into Insert mode discussed next.
Insert Mode: In order to write/edit the file, you will need to press i. This enables the editing mode for Vim. You will need to hit escape key to return back to Normal mode.
Line Mode: This mode is activated by hitting escape key when in Insert mode followed by colon :. This is used to perform operation on the file like saving and closing the file or just discarding the edits.
- :w!: This command is used to save the contents without closing the file.
- :wq!: This command is for saving + closing the file.
- :q!: This command is used for quiting out of file without saving any changes. Be careful using this command, since it will discard any changes to file that you might have made.
Note: You will need to hit enter to execute the above commands.

Basic File operations

Creating file: You can create a file using one of the option below:

Option 1#

vim test.txt

Option 2#

vi test.txt

Option 3#

touch test.txt

Opening a file: In vim you can open a file using vim followed by the file name.

References

Installing Homebrew

NOTE

This article is in progress.

Follow me at Medium Follow me at twitter

Flutter Live Booklet: Flutter component recipes

2021-03-21T00:00:00-04:00

A Flutter Live Booklet: Flutter component recipes

This article contains pointers to code samples for flutter components / widgets.

Flavoring Flutter Applications (Android & iOS)

This article describes the process of publishing Flutter applications on Android and iOS platforms in development and production environments.

Read article here
Source code is available here
Youtube video is available here

Disabled Buttons in Flutter

This micro article gives pointers to disable buttons in Flutter applications.

Read article here
Source code is available here
Youtube video is available here

Responsive Flutter layout with Expanded widget

This article shows how to use Expanded widget to create responsive layout.

Read article here
Source code is available here
Youtube video is available here

Responsive Flutter layout with FittedBox widget

This article shows how to use FittedBox widget to create responsive layout.

Read article here
Source code is available here
Youtube video is available here

Saving Image in Finger Painting Flutter App

This code recipe focuses on saving your finger painted image in device's image gallery.

Read article here
Source code is available here
Youtube video is available here

Building Cross-Platform Finger Painting App in Flutter

In this code recipe, you'll use canvas painting to build a Finger Painting App in Flutter.

Read article here
Source code is available here
Youtube video is available here
Part #2 is available here

Uploading Image to Firebase Storage in Flutter App (Android & iOS)

Code recipe to demonstrating image uploading to Firebase Storage in FlutterApp.

Read article here
Source code is available here
Youtube video is available here

Loading image from Firebase Storage in Flutter App (Android, iOS & Web)

Code recipe to demonstrate image Loading from Firebase Storage on multiple platforms (Android, iOS, and Web) using Flutter and Flutter Web.

Read article here
Source code is available here
Youtube video is available here

Navigation and Routing in Flutter App

In this article, we'll learn about navigation and routing in a Flutter app.

Read article here
Source code for Direct Navigation (Un-Named Routing) is available here
Source code for Static Navigation (Named Routing with Map) is available here
Source code for Dynamic Navigation (Named Routing with callback function) is available here
Youtube video is available here

Persisting Data in Local Database for Flutter (Android & iOS)

This article demonstrates persisting data in local database in Flutter App.

Read article here
Source code is available here
Youtube video is available here

Building Cross-Platform Finger Painting App in Flutter

In this code recipe, you'll use canvas painting to build a Finger Painting App in Flutter.

Read article here
Source code is available here
Youtube video is available here

Adding Syntax Highlighting in Flutter Cookbook App

This article describes how I used syntax_highlighter Flutter plugin to show underlying code for Flutter Cookbook's code recipes.

Read article here
Source code is available here
Youtube video is available here

Loading PDF file from Firebase Storage in Flutter App (Android, iOS & Web)

Code recipe to demonstrate loading PDF file from Firebase Storage on multiple platforms (Android, iOS, and Web) using Flutter.

Read article here
Source code is available here
Youtube video is available here

Persisting theme in LocalDatabase (Moor plugin)

Persisting theme setting in LocalDatabase using Moor plugin.

Read article here
Source code is available here
Youtube video is available here

Persisting theme using SharedPreferences (Android, iOS, and Web)

Persisting theme setting using SharedPreferences plugin.

Read article here
Source code is available here
Youtube video is available here

Implement Flutter themes using Provider

Implementing switching from light to dark theme and vice versa using Provider plugin for dependency injection and state management.

Read article here
Source code is available here
Youtube video is available here

Text-to-Speech Flutter Plugin (Android & iOS)

Code recipe to demonstrate Text-To-Speech Flutter plugin in action.

Read article here
Source code is available here
Youtube video is available here

Animating using AnimatedContainer Flutter widget

Code recipe for implementing AnimatedContainer Flutter widget.

Read article here
Source code is available here
Youtube video is available here

Animating using AnimatedPositioned Flutter widget

Code recipe for implementing AnimatedPositioned Flutter widget.

Read article here
Source code is available here
Youtube video is available here

Animating using AnimatedPadding Flutter widget

Code recipe for implementing AnimatedPadding Flutter widget.

Read article here
Source code is available here
Youtube video is available here

AnimatedOpacity Animation

Making a rectangle fade in and out.

Read article here

Hero Animation

Navigating from one page to another using Hero animation.

Read article here

Basic AppBar

Basic AppBar with a title, actions, and an overflow dropdown menu.

Read article here

BottomAppBar

Implement a BottomNavigationBar with menu, search and overflow action items.

Read article here

Search AppBar

Implementing Search action in AppBar.

Read article here

Implementing Slider & RangeSlider Flutter Widgets

Code recipe to implement Slider and RangeSlider Flutter widgets.

Read article here
Source code is available here
Youtube video is available here

Implementing Voice input for Search action in AppBar

Implementing Voice input for Search action in AppBar using Flutter for Android and iOS mobile apps.

Read article here
Source code is available here
Youtube video is available here

Migrating to Flutter 1.9: Implementing Cross-platform Firebase Login in Flutter Apps

In this article, I'll show you how Flutter 1.9 release make developing cross-platform Flutter applications simple while maximizing code reuse.

Read article here
Source code is available here
Youtube video is available here

Using ColorFiltered widget in Flutter Apps

Using ColorFiltered widget to update quiz card feedback screen's background color.

Read article here
Source code is available here
Youtube video is available here

Material icons for Flutter Web (Hummingbird)

In this video, I've explained how to fix material icons for Flutter Web (Hummingbird).

Read article here
Source code is available here

Using ColorTween in Flutter app

Widget: Color Tween
Read article here
Native (Android / iOS) recipe source code is available here
Web (Hummingbird) recipe source code is available here
Youtube video is available here

Understanding PopupMenuButton Widget

Widget: PopupMenuButton Widget
Read article here.
Source code here.
Youtube video is available here

Implementing toggle Switch for in-app Privacy Policy

Widget: Switch Widget
Read article here
Source code is available here
Youtube video is available here

Implementing Login and Register in Flutter Apps

Implementing Login and Register functionality in Flutter apps using Firebase Auth

Source code is available here
Youtube video is available here

Integrate Dialogflow in FlutterApp

Implementing Flutter FactsBot using DialogFlow

Read article about Implementing Flutter FactsBot using DialogFlow here
Source code is available here
Youtube video is available here

Implementing Login in Flutter Web (Hummingbird)

Read article here: Implementing Login in Flutter Web (Hummingbird) here
Watch Android & iOS LogIn implementation here
Setup Firebase Project
Hummingbird / Flutter Web implementation's source code is available here
Android & iOS implementation's source code is available here

Follow me at twitter: @ptyagi13 Medium: @ptyagicodecamp

Flavoring Flutter Applications (Android & iOS)

2021-03-20T00:00:00-04:00

Target Audience: Beginner

Recipe: Publish Flutter application on Android and iOS platforms for development(dev) and production (prod) environments.

Checkout the companion video tutorial:

In this article, I will give overview of the process of publishing Flutter applications on Android and iOS platforms in multiple environments. In real-world applications development process, there are multiple environments and/or stages an applications is released in. During development stage, you may want to share your app to internal testers with a backend configured for development but not ready for production purpose. If you want to distribute your app to internal testers, you need a dev variant for the application.

When you are ready to roll-out the application for public release and have production backend ready, you need a variant of same app which is connected to the production backend. Let's call this variant of app as prod flavor.

Pre-requisites

In this article, I will use default CounterApp in two variants or flavors: dev for development, and prod for production. Let's assume this app uses Firebase for backend. The dev flavor/variant of app uses one instance of Firebase project, and prod flavor uses different instance of Firebase project.

Flutter App Setup

AppConfig

Create a class AppConfig to encapsulate the app's environment/flavor type and specific name for that flavor.

class AppConfig {
  final String appName;
  final String flavor;

  AppConfig({@required this.appName, @required this.flavor});
}

Entry point for `dev` flavor

Create a file lib/main_dev.dart to run app in dev flavor. This is where you assign the flavor type and specific name for App based on that flavor.

void main() async {
  AppConfig devAppConfig = AppConfig(appName: 'CounterApp Dev', flavor: 'dev');
  Widget app = await initializeApp(devAppConfig);
  runApp(app);
}

Entry point for `prod` flavor

Create a file lib/main_prod.dart to run app in prod flavor. This is where you assign the flavor type and specific name for App based on that flavor.

void main() async {
  AppConfig devAppConfig =
      AppConfig(appName: 'CounterApp Prod', flavor: 'prod');
  Widget app = await initializeApp(devAppConfig);
  runApp(app);
}

Android

Let's configure environment variants (a.k.a Flavors) at Android platform. At this point you should have two Firebase projects setup dedicated for dev and prod environment/flavor each.

Firebase Configuration Files

First step is to download google-services.json file(s) from each Firebase project to a temporary location at your machine. Next, create two folders android/app/src/dev and android/app/src/prod for each flavor. The Firebase configuration files go under their flavor folders under android/app/src/ folder..Copy the respective google-services.json files into their flavor folders respectively. * dev flavor: android/app/src/dev/google-services.json * prod flavor: android/app/src/prod/google-services.json

Setup Flavors

Next step is to define flavors in app/build.gradle file as shown below.

android {


    defaultConfig {
        applicationId "com.pcc.counterapp"
        minSdkVersion 16
        targetSdkVersion 30
        versionCode flutterVersionCode.toInteger()
        versionName flutterVersionName
    }

    ...

    flavorDimensions "counterapp"

    productFlavors {
        dev {
            dimension "counterapp"
            applicationIdSuffix ".dev"
            resValue "string", "app_name", "Counter App Dev"
            versionNameSuffix ".dev"
        }
        prod {
            dimension "counterapp"
            applicationIdSuffix ".prod"
            resValue "string", "app_name", "Counter App Prod"
            versionNameSuffix ".prod"
        }
    }
}

That is all you need to enable flavors on Android side.

iOS

Let's create dev and prod environments(a.k.a Schemes) at iOS platform. We need to setup custom schemes at iOS side to support multiple variants.

Firebase Configuration files

Copy GooglePlayServices files under config/dev and config/prod.
Copy the config folder into the Xcode (drag and drop under Runner project)
Targets -> Runner -> Build Phase: Add script to copy correct GooglePlaySerivce file for the correct scheme. Move the script right after Link Binary with Libraries item.

environment="default"

# Regex to extract the scheme name from the Build Configuration
# We have named our Build Configurations as Debug-dev, Debug-prod etc.
# Here, dev and prod are the scheme names. This kind of naming is required by Flutter for flavors to work.
# We are using the $CONFIGURATION variable available in the XCode build environment to extract
# the environment (or flavor)
# For eg.
# If CONFIGURATION="Debug-prod", then environment will get set to "prod".
if [[ $CONFIGURATION =~ -([^-]*)$ ]]; then
environment=${BASH_REMATCH[1]}
fi

echo $environment

# Name and path of the resource we're copying
GOOGLESERVICE_INFO_PLIST=GoogleService-Info.plist
GOOGLESERVICE_INFO_FILE=${PROJECT_DIR}/config/${environment}/${GOOGLESERVICE_INFO_PLIST}

# Make sure GoogleService-Info.plist exists
echo "Looking for ${GOOGLESERVICE_INFO_PLIST} in ${GOOGLESERVICE_INFO_FILE}"
if [ ! -f $GOOGLESERVICE_INFO_FILE ]
then
echo "No GoogleService-Info.plist found. Please ensure it's in the proper directory."
exit 1
fi

# Get a reference to the destination location for the GoogleService-Info.plist
# This is the default location where Firebase init code expects to find GoogleServices-Info.plist file
PLIST_DESTINATION=${BUILT_PRODUCTS_DIR}/${PRODUCT_NAME}.app
echo "Will copy ${GOOGLESERVICE_INFO_PLIST} to final destination: ${PLIST_DESTINATION}"

# Copy over the prod GoogleService-Info.plist for Release builds
cp "${GOOGLESERVICE_INFO_FILE}" "${PLIST_DESTINATION}"

Note: I borrowed this script from this great article.

Custom Schemes

You need to create two schemes for two different environments: dev & prod. Follow the directions below:

Create Scheme: dev -> Create debug, release and profile configuration for this new scheme (Project Runner -> Configuration-> Duplicate debug, release and profile configs for dev scheme)
Rename existing Runner default scheme to prod.
Manage scheme -> Assign correct configuration to its corresponding scheme.

At this point, if you run flutter run -t lib/main_dev.dart --flavor dev in CLI, you will see information to complete the custom scheme. Finish the custom scheme setup as directed.

The Xcode project defines build configurations: Debug, Release, Profile
Flutter expects a build configuration named Debug-dev or similar.
Open Xcode to fix the problem:
  open ios/Runner.xcworkspace
1. Click on "Runner" in the project navigator.
2. Ensure the Runner PROJECT is selected, not the Runner TARGET.
3. Click the Editor->Add Configuration->Duplicate "Debug" Configuration.

   If this option is disabled, it is likely you have the target selected instead
   of the project; see:
   https://stackoverflow.com/questions/19842746/adding-a-build-configuration-in-xcode

   If you have created a completely custom set of build configurations,
   you can set the FLUTTER_BUILD_MODE=debug
   in the .xcconfig file for that configuration and run from Xcode.

4. If you are not using completely custom build configurations, name the newly created configuration debug.
Could not build the precompiled application for the device.

Scheme specific Product bundle identifier

Remember to assign correct bundle identifier for each scheme as described below.

Targets -> Runner -> Build Settings -> Product Bundle Identifier Assign the correct bundle identifier for each item as shown in screenshot below.

Running App

I find following commands handy on CLI to run app for specific flavors:

#Run app in `dev` environment
flutter run -t lib/main_dev.dart  --flavor=dev

# Run app in debug mode (Picks up debug signing config)
flutter run -t lib/main_dev.dart  --debug --flavor=dev

# Run app in release mode (Picks up release signing config)
flutter run -t lib/main_dev.dart  --release --flavor=dev

# Create appBundle for Android platform. Runs in release mode by default.
flutter build appbundle -t lib/main_dev.dart  --flavor=dev

# Create APK for dev flavor. Runs in release mode by default.
flutter build apk -t lib/main_dev.dart  --flavor=dev

Replace dev with prod to run and build app for production environment.

Source Code Repo

Recipe source code for this example is available here

References

Happy cooking with Flutter :)

Liked the article?Liked the article? Let me know with 👏👏👏

Couldn't find a topic of interest? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)_

Follow me at Medium Follow me at twitter

Disabled Buttons in Flutter

2020-11-11T00:00:00-05:00

This micro article shows how to disable the RaisedButton and FlatButton widgets in Flutter applications.

The RaisedButton / FlatButton / TextButton widget(s) can be disabled by assigning onPressed property to null. They can be disabled when onPressed property is not used at all. In order to make these widgets clickable, a function needs to be assigned to the onPressed property.

Checkout the companion video tutorial:

Disabling `RaisedButton` Widget

RaisedButton(
  child: Text("Disabled Button"),
  onPressed: null,
  disabledColor: Colors.black12,
  disabledElevation: 1,
  disabledTextColor: Colors.blueGrey,
),

Disabling `FlatButton` Widget

FlatButton(
  child: Text("Disabled Button"),
  onPressed: null,
  disabledColor: Colors.black12,
  disabledTextColor: Colors.blueGrey,
),

Disabling `TextButton` Widget

TextButton(
  child: Text("Disabled Button"),
  onPressed: null,
),

Source Code Repo

Please checkout the full source code for this example here
Flutter Cookbook2 project's source code is available here

References

Happy cooking with Flutter :)

_Liked the article? Let me know with 👏👏👏

Couldn't find a topic of interest? Please leave comments or email me about topics you would like me to write! BTW I love cupcakes and coffee both :)_

Follow me at Medium Follow me at twitter

Responsive Flutter layout with Expanded widget

2020-10-15T00:00:00-04:00

Target Audience: Beginner

Recipe: Learn to use Expanded layout widget to create responsive layouts for Flutter applications.

Focus Widget: Expanded

The Expanded widget is a single child layout widget which means it can have only one child assigned to it. In this example, the Row widget has three children built using childWidget(). Each of the child is wrapped in the Expanded widget. All children expands themselves in the direction of main-axis, which is horizontal in this case. However, when a value for flex property can be provided to resolve any competition for the space. In the second example below, each Expanded widget is provided the flex value.

Checkout the companion video tutorial:

Using `Expanded` Widget

Row(
   children: [
     Expanded(
       child: childWidget(""),
     ),
     Expanded(
       child: childWidget(""),
     ),
     Expanded(
       child: childWidget(""),
     ),
   ],
 )

Using `Expanded` widget (flex Property)

Row(
   children: [
     Expanded(
       flex: 4,
       child: childWidget("4/8"),
     ),
     Expanded(
       flex: 3,
       child: childWidget("3/8"),
     ),
     Expanded(
       flex: 1,
       child: childWidget("1/8"),
     ),
   ],
 )

Source Code Repo

Please checkout the full source code for this example here
Flutter Cookbook2 project's source code is available here

References

1.Expanded

Happy cooking with Flutter :)

_Liked the article? Let me know with 👏👏👏

Couldn't find a topic of interest? Please leave comments or email me about topics you would like me to write! BTW I love cupcakes and coffee both :)_

Follow me at Medium Follow me at twitter

Responsive Flutter layout with FittedBox widget

2020-10-01T00:00:00-04:00

Target Audience: Beginner

Recipe: Learn to use FittedBox layout widget to create responsive layouts for Flutter applications.

Focus Widget: FittedBox

The FittedBox widget is a single child layout widget which means it can have only one child assigned to it. In this example, the Row widget is added as child to FittedBox widget. The Row widget has two Image widgets as its children. Normally, the second child of Row widget will overflow to right when it renders its children on a screen size which is not sufficient to accommodate all of its children. However, with FittedBox this problem of widget overflowing is solved. It scales and position its child within the parent widget.

Checkout the companion video tutorial:

Using `FittedBox` Widget

FittedBox(
 child: Row(
   children: [
     Image.asset('assets/flutter_icon.png'),
     Image.asset('assets/flutter_icon.png'),
   ],
 ),
)

Source Code Repo

Source code is available here
Flutter Cookbook2 project's source code is available here

References

1.FittedBox

Happy cooking with Flutter :)

_Liked the article?Liked the article? Let me know with 👏👏👏

Couldn't find a topic of interest? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)_

Follow me at Medium Follow me at twitter

Saving Image in Finger Painting Flutter App

2020-08-16T00:00:00-04:00

Target Audience: Beginner

Recipe: This code recipe covers saving canvas painting created in previous article Building Cross-Platform Finger Painting App in Flutter, to device's image gallery.

Focus Plug-in: image_gallery_saver

Checkout the companion video tutorial:

`pubspec.yaml` dependencies

Add image_gallery_saver plugin in the pubspec.yaml:

dependencies:
  image_gallery_saver: ^1.5.0

Add following dependencies in pubspec.yaml to handle permissions on Android platform:

dependencies:
  permission_handler: ^5.0.1+1

iOS Info.plist

You need to add following entry in the Info.plist:

<key>NSPhotoLibraryAddUsageDescription</key>
<string>Need to access photo library to save your creation</string>

GlobalKey & RepaintBoundary Widget

We'll use global key to keep track of the widget to be saved. The Stack widget is wrapped in RepaintBoundary widget to create separate display list of its child.

class _CanvasPaintingState extends State<CanvasPainting> {
  GlobalKey globalKey = GlobalKey();

  @override
Widget build(BuildContext context) {
  return MaterialApp(
    debugShowCheckedModeBanner: false,
    home: Scaffold(
      body: GestureDetector(
        ...
        child: RepaintBoundary(
          key: globalKey,
          child: Stack(
            children: <Widget>[
              Center(
                child: Image.asset("assets/images/hut.png"),
              ),
              CustomPaint(
                size: Size.infinite,
                painter: MyPainter(
                  pointsList: points,
                ),
              ),
            ],
          ),
        ),
      ),
      ...
    ),
  );
}

}

Adding Save FAB

FloatingActionButton(
  heroTag: "paint_save",
  child: Icon(Icons.save),
  tooltip: 'Save',
  onPressed: () {
    //min: 0, max: 50
    setState(() {
      _save();
    });
  },
)

Saving Image to Gallery

The FAB's onPressed() method calls the asynchronous _save() method to save the current state of canvas as image to gallery.

Future<void> _save() async {
  RenderRepaintBoundary boundary =
      globalKey.currentContext.findRenderObject();
  ui.Image image = await boundary.toImage();
  ByteData byteData = await image.toByteData(format: ui.ImageByteFormat.png);
  Uint8List pngBytes = byteData.buffer.asUint8List();

  //Request permissions if not already granted
  if (!(await Permission.storage.status.isGranted))
    await Permission.storage.request();

  final result = await ImageGallerySaver.saveImage(
      Uint8List.fromList(pngBytes),
      quality: 60,
      name: "canvas_image");
  print(result);
}

Source code repo

Recipe source code is available here
Code recipe project's source code is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Follow me at twitter

Uploading Image to Firebase Storage in Flutter App (Android & iOS)

2020-08-16T00:00:00-04:00

Target Audience: Beginner

Recipe: Implement uploading image to Firebase Storage on Flutter Native.

Goal: In this code recipe, we'll pick an image from device camera or gallery and upload it to the Firebase Storage. Note: I'll be using Android emulator to demonstrate this code recipe. The camera functionality doesn't work in iOS simulator. You need an iOS device to use camera.

Pick Image

Upload Image

Checkout the Youtube video:

Step #1. `pubspec.yaml` dependencies

Flutter plugin for accessing images in FirebaseStorage for Native apps:

dependencies:
  firebase_storage: ^3.0.8
  firebase_core: ^0.4.0+9
  firebase_analytics: ^5.0.6

Image picker plugin to select an image from device or emulator:

dependencies:
  #Picking image from gallery
  image_picker: ^0.6.7+4

Note: This code recipe should work on Flutter Web and/or Desktop to upload image as far as it's able to get reference to the File on device. The image_picker plugin to select an image is only supported on Android and iOS platforms.

Step #2. Firebase Project review

Check out my previous article on loading image from Firebase Storage to set up Firebase project. In this code recipe, you'll need to configure firebase rule to write to the FirebaseStorage.

Step #3. Picking Image

An image file _imageFile is selected on device and/or emulator using ImagePicker Fluter plugin.

class UploadingImageToFirebaseStorage extends StatefulWidget {
  @override
  _UploadingImageToFirebaseStorageState createState() =>
      _UploadingImageToFirebaseStorageState();
}

class _UploadingImageToFirebaseStorageState
    extends State<UploadingImageToFirebaseStorage> {
  File _imageFile;

  ///NOTE: Only supported on Android & iOS
  ///Needs image_picker plugin {https://pub.dev/packages/image_picker}
  final picker = ImagePicker();

  Future pickImage() async {
    final pickedFile = await picker.getImage(source: ImageSource.camera);

    setState(() {
      _imageFile = File(pickedFile.path);
    });
  }
  ...
}

Step #4 Uploading Image to FirebaseStorage

Once an image is selected using ImagePicker, it will be displayed in the screen. Clicking on 'Upload Image' button on screen will upload the image to Firebase Storage. Make sure that FirebaseStorage write rules are configured appropriately. I'm temporarily enabling write access on FirebaseStorage access using allow write: if true;. Make sure to disable it once you've confirmed the functionality. It's always good idea to put write access behind the successful user login.

The following code will take the image file on device and upload it to the uploads folder in the FirebaseStorage.

class _UploadingImageToFirebaseStorageState
    extends State<UploadingImageToFirebaseStorage> {
  File _imageFile;

  ...

  Future uploadImageToFirebase(BuildContext context) async {
    String fileName = basename(_imageFile.path);
    StorageReference firebaseStorageRef =
        FirebaseStorage.instance.ref().child('uploads/$fileName');
    StorageUploadTask uploadTask = firebaseStorageRef.putFile(_imageFile);
    StorageTaskSnapshot taskSnapshot = await uploadTask.onComplete;
    taskSnapshot.ref.getDownloadURL().then(
          (value) => print("Done: $value"),
        );
  }
  ...
}

iOS Info.list

Don't forget to add camera related permissions to Info.plist.

<key>NSCameraUsageDescription</key>
<string>Need to access your camera to capture a photo add and update profile picture.</string>

<key>NSPhotoLibraryUsageDescription</key>
<string>Need to access your photo library to select a photo add and update profile picture</string>

Source code repo

Recipe source code is available here
Flutter Cookbook Project's source code is available here

References:

Happy cooking with Flutter :)

_Liked the article? Let me know with 👏👏👏

Couldn't find a topic of interest? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)_

Follow me at Medium Follow me at twitter

Lottie Animation in the Flutter Application

2020-07-14T00:00:00-04:00

Target Audience: Beginner

Recipe: Integrate Lottie Animation in the Flutter application.

Checkout the companion video tutorial:

`pubspec.yaml` dependency

Add TODO plugin dependency as below:

dependencies:
  flutter:
    sdk: flutter

HEADLINE

Source Code Repo

Recipe source code for TODO class is available here
Flutter Cookbook project's source code is available here

References

Happy cooking with Flutter :)

Liked the article? Couldn't find a topic of your interest? Please leave comments or email me about topics you would like me to write! BTW I love cupcakes and coffee both :)

Follow me at twitter

Navigation and Routing in Flutter App

2020-06-17T00:00:00-04:00

Target Audience: Beginner

Recipe: Implement Navigation from one page to another page using three different techniques.

Focus Widget: Navigator Widget

Goals: We'll implement navigation from homepage's list item to its detailed view. In this recipe, we'll do two things:

User Interface:: Create a homepage, PageListing - consists of three items. Another page, PageDetails to display details for each item. Clicking on an item in PageListing page, will open the detailed view - PageDetails for that item.
Navigation: Implement navigation from PageListing (homepage) to PageDetails (details page) in three different ways.
Sending data: Sending data from PageListing to PageDetails page. The Item object is passed along to target page.
Receiving data: Receiving data from PageDetails page. Navigator.pop() is used to send text from PageDetails to PageListing page.

Checkout the YouTube video tutorial:

Building Interface

First, we'll build two pages to navigate from one to another. The First page is called PageListing page/screen. The second page is PageDetails page/screen.

`PageListing` Screen

The PageListing is a StatelessWidget. This the homepage of this sample app. It consists of three list items. Each item has a picture and sample title and subtitle as shown in the screenshot below. The appBar shows the name of the navigation/routing used.

The items are stored in a global List<Item> seasideList.

List<Item> seasideList = [
  Item(
      name: 'Sea 1',
      image: 'assets/images/sea2.jpg',
      details: "Ocean view for Sea 1"),
  Item(
      name: 'Sea 2',
      image: 'assets/images/sea3.jpg',
      details: "Ocean view for Sea 2"),
  Item(
      name: 'Sea 3',
      image: 'assets/images/sea-rocks.jpg',
      details: "Ocean view for Sea 3")
];

The PageListing implementation:

class PageListing extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      //Shows the name of navigation type/routing used
      appBar: AppBar(
        title: Text('Un-Named Routes'),
      ),
      body: ListView.builder(
          itemCount: seasideList != null ? seasideList.length : 0,
          itemBuilder: (BuildContext context, int index) {
            return ListTile(
              leading: CircleAvatar(
                backgroundImage: ExactAssetImage(seasideList[index].image),
              ),
              title: Text("${seasideList[index].name}"),
              subtitle: Text("${seasideList[index].details}"),
              onTap: () {
                 //Tapping on listItem navigates to PageDetails
                _navigateToPageDetails(context, seasideList[index]);
              },
            );
          }),
    );
  }

  //Launches PageDetails and awaits the results from Navigator.pop() called from PageDetails.
  _navigateToPageDetails(BuildContext context, Item item) async {

    //Holds the results returned from PageDetails.
    final resultFromPageDetails;

    //TODO: Navigation implementations are discussed in upcoming Navigation section of this article

    //snackbars is used to display the result returned from another page.
    //Hide any previous snackbars and show the new resultFromPageDetails.
    Scaffold.of(context)
      ..removeCurrentSnackBar()
      ..showSnackBar(SnackBar(content: Text("$resultFromPageDetails")));
  }
}

`PageDetails` Screen

This page displays details for the homepage's list items. It's a simple page displaying item's image, details and its name in appBar. It has a FloatingActionButton or FAB in the bottom-right corner. Clicking on this navigates back to home page with a message that the item is marked as favorite. This is used to demonstrate passing data from detailed page back to homepage.

The PageDetails implementation:

class PageDetails extends StatelessWidget {
  final Item item;

  const PageDetails({Key key, this.item}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(item.name),
      ),
      body: Column(
        children: [
          Image.asset(item.image),
          SizedBox(
            height: 10,
          ),
          Text(
            item.details,
            style: TextStyle(fontWeight: FontWeight.bold, fontSize: 20),
          ),
        ],
      ),
      floatingActionButton: FloatingActionButton(
        child: Icon(Icons.favorite_border),
        onPressed: () {
          //Current item's name along with message is sent back to last screen
          Navigator.pop(context, '${item.name} is marked as favorite.');
        },
      ),
    );
  }
}

`Item`

The Item is a data model to represent each row in homepage's list.

class Item {
  final String name;
  final String image;
  final String details;
  Item({this.name, this.image, this.details});
}

Navigation

There are three ways to create navigation in Flutter:

Direct Navigation: Direct navigation is implemented with MaterialPageRoute. This is also known as un-named routing.
Static Navigation: Static navigation is implemented by assigning a map of routes to MaterialApp's routes property. The route name is pushed using Navigator.pushNamed(...). This is known as Named Routing.
Dynamic Navigation: In this navigation, routes are generated by implementing onGenerateRoute callback in the MaterialApp class. This is a type of Named Routing as well, and the route name is pushed using Navigator.pushNamed(...).

Let's go ahead and check out navigation implementations.

Direct Navigation

Direct navigation is also known as un-named routing. It is implemented with MaterialPageRoute. The MaterialPageRoutes is pushed directly to the navigator. This approach contributes to boilerplate code which multiplies with growing screens/pages. It is very hard to keep track of logic around these routes since its spread out in multiple classes.

Entry point:

The MaterialApp assigns PageListing screen as its home property.

//Using Direct Navigation (un-named routing)
void main() => runApp(
      MaterialApp(
        debugShowCheckedModeBanner: false,
        home: PageListing(),
      ),
    );

Navigation Implementation:

The Navigator.push is used to implement this routing. The MaterialPageRoute is pushed on the Navigator. The Navigator is a widget that manages a set of child widgets as a stack. These child widgets are pages/screens pushed on the Navigator. Navigator refers to these children as Route object.

Sending Data:

The MaterialPageRoute uses builder to build the primary contents of the route (page/screen). The Item object is passed as argument to PageDetails widget.

MaterialPageRoute(
  builder: (context) => PageDetails(
    item: item,
  ),
),

Receiving Data:

The Navigator.push returns a Future that completes after calling Navigator.pop on the PageDetails Screen.

_navigateToPageDetails(...):

The _navigateToPageDetails(...) is called on tapping a list item. The PageDetails route is pushed on the Navigator. The Navigator.push returns a Future which contains the data sent back from Navigator.pop in PageDetails widget. This data is stored in resultFromPageDetails variable, and displayed in a SnackBar widget

class PageListing extends StatelessWidget {

  ...

  //Launches PageDetails and awaits the results from Navigator.pop() called from PageDetails.
  _navigateToPageDetails(BuildContext context, Item item) async {

    //Navigation implementations are different for each part.
    //Part#1. Un-named
    final resultFromPageDetails = await Navigator.push(
      context,
      MaterialPageRoute(
        builder: (context) => PageDetails(
          item: item,
        ),
      ),
    );

    //snackbars is used to display the result returned from another page.
    //Hide any previous snackbars and show the new resultFromPageDetails.
    Scaffold.of(context)
      ..removeCurrentSnackBar()
      ..showSnackBar(SnackBar(content: Text("$resultFromPageDetails")));
  }
}

Static Navigation

The static navigation is implemented by assigning a Map of routes (pages/screens) to MaterialApp's routes property. The route name is pushed using Navigator.pushNamed(...). This is known as Named Routing because each page is given a unique name, which is pushed on Naviagtor widget.

The MaterialApp and WidgetApp provides the routes property. This property allows to specify routes in Map<String, WidgetBuilder>. This option is great when there is no logic around the routes. For example, authentication or verification before you show the page. Only the data available global to app can be passed on to the second page.

Entry point:

In this application, there are two ways to assign the initial page, PageListing(). One way is to assign PageListing() widget to home property. Another ways is to assign a Map containing </, PageListing()> entry to routes property. The / represents the home page mapping.

//Using Static Navigation
void main() => runApp(
      MaterialApp(
        debugShowCheckedModeBanner: false,
        //home: PageListing(),
        //Part#2. Named route using Map
        routes: <String, WidgetBuilder>{
          '/': (BuildContext context) => PageListing(),
          '/details': (BuildContext context) => PageDetails(
                item: seasideList[0],
              ),
        },
      ),
    );

Navigation Implementation:

All routes/pages have entries in routes table above. The Map entry '</details, PageDetails()>' is added to navigate to the PageDetails page. The /details is the alias/name to the PageDetails page. This name is pushed on the Naviagtor widget using Naviagtor.pushNamed.

Navigator.pushNamed(context, '/details')

Sending Data:

The data can be passed to the PageDetails at the top-level only where the routes are assigned to routes property. In this case, only globally available data can be passed. In this implementation, only first item seasideList[0] detail page will open for any selection on the homepage.

routes: <String, WidgetBuilder>{
  '/': (BuildContext context) => PageListing(),
  '/details': (BuildContext context) => PageDetails(
        item: seasideList[0],
      ),
},

Receiving Data:

The Navigator.push returns a Future that completes after calling Navigator.pop on the PageDetails Screen. This is similar to what we discussed earlier.

_navigateToPageDetails(...):

This is similar to what we discussed earlier except Navigator.pushNamed is used for pushing the routes on the stack.

class PageListing extends StatelessWidget {

  ...

  //Launches PageDetails and awaits the results from Navigator.pop() called from PageDetails.
  _navigateToPageDetails(BuildContext context, Item item) async {

    //Navigation implementations are different for each part.
    //Part#2. Named route with Maps
    final result = await Navigator.pushNamed(context, '/details');

    //snackbars is used to display the result returned from another page.
    //Hide any previous snackbars and show the new resultFromPageDetails.
    Scaffold.of(context)
      ..removeCurrentSnackBar()
      ..showSnackBar(SnackBar(content: Text("$result")));
  }
}

Dynamic Navigation

In dynamic navigation, routes are generated by implementing onGenerateRoute callback in the MaterialApp class. This is a type of Named Routing that makes use of onGenerateRoute property.

The MaterialApp and WidgetApp provides the onGenerateRoute property. It lets you specify a function, say generateRoute returning a route. It allows the data pass using RouteSettings. It carries the data that might be useful in constructing a Route.

Any verification logic can be easily be applied before showing the target page. There's always an option to default "not found" page when route or match is not found.

Entry point:

The entry page PageListing is assigned to home property. The initialRoute property can be used to assign the beginning route/page. The generateRoute callback function handles the navigational logic.

//Using Dynamic Navigation
void main() => runApp(
      MaterialApp(
        debugShowCheckedModeBanner: false,
        home: PageListing(),
        //Part#3. Named with onGenerateRoute
        initialRoute: '/',
        onGenerateRoute: generateRoute,
      ),
    );

Navigation Implementation:

The Navigator use Route object to represent the page/screen. The generateRoute() function returns the appropriate route based on the matching name. The RouteSettings is useful in passing around these route names and arguments, if any. The route name is extracted using routeSettings.name. The arguments can be extracted using routeSettings.arguments. When no match is found, a common default page is shown to user displaying the appropriate message.

Route<dynamic> generateRoute(RouteSettings routeSettings) {
  final args = routeSettings.arguments;

  switch (routeSettings.name) {
    case '/':
      return MaterialPageRoute(
        builder: (context) => PageListing(),
      );

    case '/details':
      if (args is Item) {
        return MaterialPageRoute(
          builder: (context) => PageDetails(
            item: args,
          ),
        );
      }

      return MaterialPageRoute(
        builder: (context) => PageNotFound(),
      );

    default:
      return MaterialPageRoute(
        builder: (context) => PageNotFound(),
      );
  }
}

Sending Data:

This is similar to the last Named Routing approach. In this approach, we can pass item as arguments. This arguments is extracted and passed to the PageDetails widget in generateRoute routing function.

Navigator.pushNamed(
      context,
      '/details',
      arguments: item,
    )

Receiving Data:

The Navigator.push returns a Future that completes after calling Navigator.pop on the PageDetails Screen. This is similar to what we discussed earlier.

_navigateToPageDetails(...):

This is similar to what we discussed earlier except Navigator.pushNamed is used to pass the data along in addition to pushing the named routes on the stack.

class PageListing extends StatelessWidget {

  ...

  //Launches PageDetails and awaits the results from Navigator.pop() called from PageDetails.
  _navigateToPageDetails(BuildContext context, Item item) async {
    //Navigation implementations are different for each part.
    //Part#3. Named route using callback function
    final result = await Navigator.pushNamed(
      context,
      '/details',
      arguments: item,
    );

    //snackbars is used to display the result returned from another page.
    //Hide any previous snackbars and show the new resultFromPageDetails.
    Scaffold.of(context)
      ..removeCurrentSnackBar()
      ..showSnackBar(SnackBar(content: Text("$result")));
  }
}

PageNotFound:

class PageNotFound extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text("Page not found"),
      ),
      body: Center(
        child: Text("Page is not available."),
      ),
    );
  }
}

Source Code Repo

Source code for Direct Navigation (Un-Named Routing) is available here
Source code for Static Navigation (Named Routing with Map) is available here
Source code for Dynamic Navigation (Named Routing with callback function) is available here
Flutter Cookbook project's source code is available here

References

Happy cooking with Flutter :)

Liked the article? Couldn't find a topic of your interest? Please leave comments or email me about topics you would like me to write! BTW I love cupcakes and coffee both :)

Follow me at twitter

Dart's Callable Classes

2020-06-14T00:00:00-04:00

Introduction

In Dart, functions are objects too. It's an object of type Function. Similar to other objects, functions can be passed as arguments to other functions, and can be assigned to variables as well.

A Callable class allows its instance to be called as function. This feature of Dart language is useful in making named-functions.

Check out YouTube Video

Implementing Callable Class

All Dart functions have call method. In order to make a class Callable, the call() method needs to be implemented. Let's declare a callable class below:

class Addition {
  int call(int a, int b) => a + b;
}

The above class' call method takes two arguments and returns their sum.

Using Callable Class

Let's check out using the Addition callable class in code below. The addition object is of Addition type. Now, addition(1, 2) can be called to calculate the sum of given numbers.

void main() {
  Addition addition = Addition();
  var result = addition(1, 2);
  print(result);
}

Output:

Summary

In this article, we learned that Dart is a true object-oriented language. Dart's functions are also objects. We learned to implement a callable class.

That's it for this article. Check out the Dart Vocabulary Series for other Dart stuff.

Source Code

Please checkout the source code at Github here

References

Happy Darting :)

_Liked the article? Couldn't find a topic of interest? Please leave a comment or reach out at twitter about the topics you would like me to share!

BTW I love cupcakes and coffee both :)_

Follow me at Medium

Dart Generators

2020-06-07T00:00:00-04:00

Introduction

Dart generator functions are used to generate sequence of values on-demand lazily. Such value sequence can be generated either synchronously or asynchronously. There are two types of built-in generator functions available to support both scenarios:

Synchronous Generator: Synchronous generator function returns an Iterable object. That means first the values are generated and then returned lazily on-demand by the function.

Iterable: A collection of values, or "elements", that can be accessed sequentially.

Asynchronous Generator: Asynchronous generator function returns a Stream object. The sequence of values is generated on demand as they become available.

Stream: A source of asynchronous data events.

Check out YouTube Video

Let's understand generator functions with help of an example. We'll generate numbers starting from a given number say 5 until 0, using generator functions. We'll observe both ways (asynchronous and synchronous generators) to create this number sequence.

Using `sync*` - Synchronous Generator

The function Iterable<int> countDownFromSync(int num) sync* takes a number as num, and sends out all numbers starting from num until 0. The synchronous generator function is marked with sync*. The values are returned using yield keyword. The iterable sequence receives the number sequence and print each number using for loop. This number sequence actually is not generated until it has been accessed by for loop.

main1():

void main1() {
  print("Getting CountDown Iterable [sync* + yield]");
  Iterable<int> sequence = countDownFromSync(5);

  print("Starting...");

  for (int value in sequence) {
    print(value);
  }
  print("DONE");
}

//sync*
Iterable<int> countDownFromSync(int num) sync* {
  while (num > 0) {
    yield num--;
  }
}

Output:

The sync* helps to generate values in a synchronous manner. Note that Starting... message is printed before for loop's execution. The DONE message is executed at last as well.

Getting CountDown Iterable [sync* + yield]
Starting...
5
4
3
2
1
DONE

Using `async*` - Asynchronous Generator

The function Stream<int> countDownFromAsync(int num) async* takes a number as num, and deliver number sequence starting from num until 0. The asynchronous generator function is marked with async*. The values are returned using yield keyword. The stream sequence receives the number sequence. Its values can be accessed as soon as it got started listening upon.

main2():

void main2() {
  print("Getting CountDown Stream [async* + yield]");
  Stream<int> sequence = countDownFromAsync(5);

  print("Starting...");

  sequence.listen((int value) {
    print(value);
  });
  print("DONE");
}

//async*
Stream<int> countDownFromAsync(int num) async* {
  while (num > 0) {
    yield num--;
  }
}

Output:

The async* helps to generate values in an asynchronous manner. Note that Starting... and DONE messages/setup are printed before actual stream's values are printed. The values are printed as they become available after the setup code.

Getting CountDown Stream [async* + yield]
Starting...
DONE
5
4
3
2
1

Using `sync* + yield*` - Recursive Synchronous Generator

When generator functions are used recursively, yield* is used to mark such recursive function calls. This example shows how to use generator functions recursively. You'll notice the same output as for the non-recursive implementation. The keyword yield* is used for the function that's called recursively.

void main3() {
  print("Getting CountDown Iterable [sync* + yield*]");
  Iterable<int> sequence = countDownFromSyncRecursive(5);

  print("Starting...");

  for (int value in sequence) {
    print(value);
  }
  print("DONE");
}

//sync* + yield* for recursive functions
Iterable<int> countDownFromSyncRecursive(int num) sync* {
  if (num > 0) {
    yield num;

    yield* countDownFromSyncRecursive(num - 1);
  }
}

Output:

Getting CountDown Iterable [sync* + yield*]
Starting...
5
4
3
2
1
DONE

Using `async* + yield*` - Recursive Asynchronous Generator

This is an example of using an asynchronous generator function recursively. It also has the same output as its non-recursive counter-part.

void main4() {
  print("Getting CountDown Stream [async* + yield*]");
  Stream<int> sequence = countDownFromAsyncRecursive(5);

  print("Starting...");

  sequence.listen((int value) {
    print(value);
  });
  print("DONE");
}

//async* + yield* for recursive functions
Stream<int> countDownFromAsyncRecursive(int num) async* {
  if (num > 0) {
    yield num;

    yield* countDownFromAsyncRecursive(num - 1);
  }
}

Output:

Getting CountDown Stream [async* + yield*]
Starting...
DONE
5
4
3
2
1

Summary

In this article, we saw how to use Dart's generator function to produce an on-demand sequence of values synchronously and asynchronously in an iterative and recursive manner.

That's it for this article. Check out the Dart Vocabulary Series for other Dart stuff.

Source Code

Please checkout the source code at Github here

References

Happy Darting :)

_Liked the article? Couldn't find a topic of interest? Please leave a comment or reach out at twitter about the topics you would like me to share!

BTW I love cupcakes and coffee both :)_

Follow me at Medium

A Dart/Flutter Vocabulary Series

2020-05-22T00:00:00-04:00

The Dart & Flutter Vocabulary Series

Learn basics of Dart programming language. Flutter uses Dart to build awesome cross-platform mobile, web, and desktop applications. This series uses code recipes to explain Dart/Flutter usage and terminologies.

Follow me at twitter: @ptyagi13 Medium: @ptyagicodecamp

Dart's Callable Classes

This article introduces the Callable Class feature of the Dart language.

Read article here
Source code is available here
Youtube video is available here

Dart Generators

This article explains usage of Dart Generator functions to generate sequence of values on-demand.

Read article here
Source code is available here
Youtube video is available here

Futures: Asynchronous Programming with Dart (Part1)

This article is the first part of introduction to asynchronous programming with Dart, and covers Futures in Dart.

Read article here
Source code is available here
Youtube video is available here

Streams: Asynchronous Programming with Dart (Part2)

This article is the second part of introduction to asynchronous programming with Dart, and covers Streams in Dart.

Read article here
Source code is available here
Youtube video is available here

Types of Streams: Asynchronous Programming with Dart (Part3)

This article is the third and last part of introduction to asynchronous programming with Dart, and covers types of Streams in Dart.

Read article here
Source code is available here
Youtube video is available here

Dart Libraries (Part-1)

This article is the Part-1 of introduction to using libraries in Dart/Flutter.

Read article here
Source code is available here
Youtube video is available here

Dart Libraries (Part-2)

This article is the Part-2 of introduction to using libraries in Dart/Flutter.

Read article here
Source code is available here
Youtube video is available here

Dart Generics

This article explains Dart Generics and how to use them.

Read article here
Source code is available here
Youtube video is available here

Dart static keyword

This article demonstrates using static keyword in Dart.

Read article here
Source code is available here
Youtube video is available here

Dart Mixins

This article explains Dart Mixins and when and how to use them.

Read article here
Source code is available here
Youtube video is available here

Dart Enums

This article explains Dart Enums and when and how to use them.

Read article here
Source code is available here
Youtube video is available here

Dart Extensions

This article explains what extension methods, operators, and properties are, and how to use them.

Read article here
Source code is available here
Youtube video is available here

The `runes` Property

In this article, we'll explore Dart language's one of the String class property known as runes to retrieve UTF-16 unicodes.

Read article here
Source code is available here
Youtube video is available here

The `runtimeType` Property

The runtimeType property is used to find out the runtime type of the object.

Read article here
Source code is available here
Youtube video is available here

Types of Streams: Asynchronous Programming with Dart

2020-05-22T00:00:00-04:00

Target Audience: Beginner

Introduction

This article is a part of three part series focused on asynchronous Programming with Dart. This article covers types of Streams in Dart to execute program asynchronously.

Part-1 Futures: Asynchronous Programming with Dart
Part-2 Streams: Asynchronous Programming with Dart
Part-3 (Current) Types of Streams: Asynchronous Programming with Dart

Checkout the YouTube video:

Types of Streams

Single subscription

Single subscription streams are meant to deliver events in order. This type of stream is used when order of events received matters like reading a file. Such type of Streams can be listened only once. Attempting to listening them again will throw an exception.
Broadcast (Multiple subscribers)

Broadcast streams are intended to deliver events to their subscribers. Any subscriber can start listening to events as soon as they subscribe to it. A Broadcast stream can be listened multiple times.

Note: A Single Subscription stream can be converted into broadcast streams by using asBroadcastStream() method.

Subscribing To Stream

In this section, we'll see two ways to subscribe to a stream:

Using listen() method
Using Subscription's Handler

Using `listen()`

Example#1.

//This will generate a stream and return reference to it.
Stream<int> createNumberStreamWithException(int last) async* {
  for (int i = 1; i <= last; i++) {
    if (i == 5) {
      throw new Exception("Demo exception when accessing 5th number");
    }
    yield i; //to be able to send spaced out events
  }
}

//Example#1. Subscribing to Stream using `listen()` method
void subscribeUsingListen() {
  Stream stream = createNumberStreamWithException(5);

  stream.listen(
    (x) => print("number: $x"),
    onError: (err) => print("error: $err"),
    onDone: () => print("Done"),
  );
}
//----END----//

//Entry point function
void main() {
  //Run Example#1.
  subscribeUsingListen();
}

Output:

number: 1
number: 2
number: 3
number: 4
error: Exception: Demo exception when accessing 5th number
Done

Source Code is available here- Example#1.

Using Subscription's Handler

A Stream subscription handler can be get using passing null in the listen() like this stream.listen(null).

Example#2.

//This will generate a stream and return reference to it.
Stream<int> createNumberStreamWithException(int last) async* {
  for (int i = 1; i <= last; i++) {
    if (i == 5) {
      throw new Exception("Demo exception when accessing 5th number");
    }
    yield i; //to be able to send spaced out events
  }
}

//Example#2. Subscribing to Stream using subscription handler
void subscribeUsingSubscriptionHandler() {
  Stream stream = createNumberStreamWithException(5);

  var subscription = stream.listen(null);
  subscription.onData((x) => print("number $x"));
  subscription.onError((err) => print("error: $err"));
  subscription.onDone(() => print("Done"));
}
//----END----//

//Entry point function
void main() {
  //Run Example#2.
  subscribeUsingSubscriptionHandler();
}

Output:

number 1
number 2
number 3
number 4
error: Exception: Demo exception when accessing 5th number
Done

Source Code is available here- Example#2.

Sample Stream

I'll be using following stream to demonstrate upcoming examples of Stream operations. If you're running code snippets in DartPad, make sure to add following code for creating a stream first.

//This will generate a stream and return reference to it.
Stream<int> createNumberStream(int last) async* {
  for (int i = 1; i <= last; i++) {
    yield i; //to be able to send spaced out events
  }
}

Single Subscription Stream Operations

In this section, I'll be discussing usage of Stream's methods with help of examples.

Using `where()` Method

Let's see an example to find and print a number greater than 3 in number stream in example above. In this example listen() method subscribes to stream and acts like a callback. Every time, a number meeting the criteria is found, its sent over to callback to take further action on it.

Example#3.

//Example#3. Demonstrating usage of `where()`
void filterUsingWhere() {
  var stream = createNumberStream(5);
  stream
      .where((x) => x > 3) //Filters numbers greater than 3
      .listen((x) => print(x)); //prints numbers filtered
}
//----END----//

//Entry point function
void main() {
  //Run Example#3.
  filterUsingWhere();
}

Output:

4
5

Source Code is available here- Example#3.

Using Stream's Properties

In this section, we'll learn about following properties of a Stream with help of examples. Let's use the previous example to understand the usage of these properties in action. Notice the pair method then() rather listen() when using properties.

`first`

Retrieves the first event of the stream.

Example#4.

//Example#4. Demonstrating usage of `first`
void first() {
  var stream = createNumberStream(5);

  //print the first number/event
  stream.first.then(
    (x) => print("First event: $x"),
  );
}
//----END----//

//Entry point function
void main() {
  //Run Example#4.
  first();
}

Output:

First event: 1

Source Code is available here- Example#4.

`last`

Retrieves the last event of the stream.

Example#5.

//Example#5. Demonstrating usage of `last`
void last() {
  //A fresh stream is needed.
  //Single subscription stream can't be re-listened.
  var stream = createNumberStream(5);
  //print the last number/event
  stream.last.then((x) => print("Last event: $x"));
}
//----END----//

//Entry point function
void main() {
  //Run Example#5.
  last();
}

Output:

Last event: 5

Source Code is available here- Example#5.

`length`

Retrieves length of the stream.

Example#6.

//Example#6. Demonstrating usage of `length`
void length() {
  var stream = createNumberStream(5);
  //print the length of the stream
  stream.length.then((x) => print("Length of Stream: $x"));
}
//----END----//

//Entry point function
void main() {
  //Run Example#6.
  length();
}

Output:

Length of Stream: 5

Source Code is available here- Example#6.

`isEmpty`

Checks if stream is empty of not.

Example#7.

//Example#7. Demonstrating usage of `isEmpty`
void isEmpty() {
  var stream = createNumberStream(5);
  //Check if stream is empty
  stream.isEmpty.then((x) => print("Is Empty : $x"));

  //Create an empty stream
  stream = createNumberStream(0);
  //Verify an empty stream
  stream.isEmpty.then((x) => print("Is Empty : $x"));
}
//----END----//

//Entry point function
void main() {
  //Run Example#7.
  isEmpty();
}

Output:

Is Empty : false
Is Empty : true

Source Code is available here- Example#7.

Broadcast Streams Operations

Let's convert single subscription stream in previous example to broadcast stream using asBroadcastStream() method and re-examine all properties again. This time we don't need to create a fresh stream for each operation. Broadcast streams can have multiple subscribers or can be listened multiple times.

Example#8.

//Example#8. Demonstrating BroadcastStream basic operations
void broadcastStreamBasicOperations() {
  var stream = createNumberStream(5);

  //Converting to broadcastStream
  var bStream = stream.asBroadcastStream();

  //check if stream is broadcast stream or single
  if (bStream.isBroadcast) {
    print("Broadcast Stream");
  } else {
    print("Single Stream");
  }
  //print the first number/event
  bStream.first.then((x) => print("First event: $x"));

  //print the last number/event
  bStream.last.then((x) => print("Last event: $x"));

  //print the length of the stream
  bStream.length.then((x) => print("Length of Stream: $x"));

  //Check if stream is empty
  bStream.isEmpty.then((x) => print("Is Empty : $x"));

  //empty stream on purpose
  stream = createNumberStream(0);
  bStream = stream.asBroadcastStream();
  bStream.isEmpty.then((x) => print("Is Empty : $x"));
}
//----END----//

//Entry point function
void main() {
  //Run Example#8.
  broadcastStreamBasicOperations();
}

Output:

Broadcast Stream
First event: 1
Is Empty : false
Is Empty : true
Last event: 5
Length of Stream: 5

Source Code is available here- Example#8.

Let's see few methods that extract part of the data stream and create sub-streams of data. Listeners listen to these output sub-streams.

Using `take()` Method

Creates the sub-stream for 'given number' of first events of original stream. Listener listens to this sub-stream and print all elements.

Example#9.

//Example#9. Demonstrating BroadcastStream `take()` method
void broadcastStreamTake() {
  var stream = createNumberStream(5);

  //Converting to broadcastStream
  var bStream = stream.asBroadcastStream();

  //Creates a sub stream of 2 elements and
  //listen on it
  bStream.take(2).listen(
        (x) => print("take() : $x"),
      );
}
//----END----//

//Entry point function
void main() {
  //Run Example#9.
  broadcastStreamTake();

}

Output:

take() : 1
take() : 2

Source Code is available here- Example#9.

Using `skip()` Method

Creates sub-stream of original stream after skipping first 'given number' of events from original stream. Listener listens to this sub-stream and print all elements.

Example#10.

//Example#10. Demonstrating BroadcastStream `skip()` method
void broadcastStreamSkip() {
  var stream = createNumberStream(5);

  //Converting to broadcastStream
  var bStream = stream.asBroadcastStream();

  //skips first two numbers from [1,2,3,4,5]
  bStream.skip(2).listen(
        (x) => print("skip() : $x"),
      );
}
//----END----//

//Entry point function
void main() {
  //Run Example#10.
  broadcastStreamSkip();
}

Output:

skip() : 3
skip() : 4
skip() : 5

Source Code is available here- Example#10.

Using `takeWhile()` Method

The takeWhile() method does the same thing as take() when a condition is full-filled. Let's add condition that pick/take first elements when number is positive but less than 3. There are two such numbers in [1, 2, 3, 4, 5], which is 1 and 2. takeWhile() will check the condition and will print these 2 numbers on console.

Example#11.

//Example#11. Demonstrating BroadcastStream `takeWhile()` method
void broadcastStreamTakeWhile() {
  var stream = createNumberStream(5);

  //Converting to broadcastStream
  var bStream = stream.asBroadcastStream();

  //Creates a sub-stream of items less than 3, and prints the sub-stream of [1,2].
  bStream.takeWhile((x) => x > 0 && x < 3).listen(
        (x) => print("takeWhile() : $x"),
      );
}
//----END----//

//Entry point function
void main() {
  //Run Example#11.
  broadcastStreamTakeWhile();

}

Output:

takeWhile() : 1
takeWhile() : 2

Source Code is available here- Example#11.

Using `skipWhile()` method

The skipWhile() method is similar to skip() in addition to honoring the condition.

Example#12.

//Example#12. Demonstrating BroadcastStream `skipWhile()` method
void broadcastStreamSkipWhile() {
  var stream = createNumberStream(5);

  //Converting to broadcastStream
  var bStream = stream.asBroadcastStream();

  //skips elements which are positive and
  //less than 3, and prints rest.
  bStream
      .skipWhile((x) => x > 0 && x < 3)
      .listen((x) => print("skipWhile() : $x"));
}
//----END----//

//Entry point function
void main() {
  //Run Example#12.
  broadcastStreamSkipWhile();

}

Output:

skipWhile() : 3
skipWhile() : 4
skipWhile() : 5

Source Code is available here- Example#12.

Modifying Stream: `transform()` Method

Transform stream's events to another type. In this example, a String of integers is transformed to stream of strings.

Example#13.

//Example#13. Demonstrating modifying a stream using `transform()` method
void modifyStreamUsingTransform() {
  //Stream of integer events is created.
  var stream = createNumberStream(5);

  //StreamTransformer prints the transformed event
  var transformer =
      StreamTransformer<int, String>.fromHandlers(handleData: (value, sink) {
    sink.add("My number is $value");
  });

  stream.transform(transformer).listen(
        (x) => print(x),
        onError: (err) => print("error: $err"),
        onDone: () => print("Done"),
      );
}
//----END----//

//Entry point function
void main() {
  //Run Example#13
  modifyStreamUsingTransform();

}

Output:

My number is 1
My number is 2
My number is 3
My number is 4
My number is 5
Done

Source Code is available here- Example#13.

References

Happy cooking with Dart and Flutter :)

Liked the article? Couldn't find a topic of your interest? Please leave comments or email me about topics you would like me to write! BTW I love cupcakes and coffee both :)

Streams: Asynchronous Programming with Dart

2020-05-21T00:00:00-04:00

Target Audience: Beginner

Introduction

This article is a part of three part series focused on asynchronous Programming with Dart. This article covers Streams in Dart to execute program asynchronously.

Part-1 Futures: Asynchronous Programming with Dart
Part-2 (Current) Streams: Asynchronous Programming with Dart
Part-3 Types of Streams: Asynchronous Programming with Dart

Checkout the YouTube video:

Streams

A Stream is a sequence of asynchronous events. Streams are useful in providing an asynchronous sequence of data.

Key Terms

Stream: A Stream is a sequence of asynchronous events. It lets you know whenever next event is ready rather you asking for it.

Data Sequence: A Data sequence is made up of either user-generated event or data read from files.

async: Functions with await keyword needs to be marked as async keyword. Functions marked with async keywords doesn't suspend immediately, but execute synchronously until first await or return is called.

Creating Stream

In this section, we'll learn to generate a stream of events consists of numbers using two different ways.

Using Generator Function

One way to create stream by using generator function. It helps to produce lazily a sequence of values. In this example, we'll create stream using for loop and yield keyword. The yield keywords is helpful in delivering values. The async* is an asynchronous generator that returns a Stream object.

Example#1:

//Example#1. Creating Stream (of numbers) using asynchronous Generators
//Using yield, async*

//This will return a reference to the stream
Stream<int> createNumberStream(int last) async* {
  for (int i = 1; i <= last; i++) {
    yield i; //to be able to send spaced out events
  }
}

//Printing numbers/events of Stream (Listening to Stream)
printStream(Stream stream) {
  stream.listen((s) => print(s));
}

void createStreamUsingGenerators() async {
  //Using `yield`, async* keywords
  var stream = createNumberStream(5);
  printStream(stream);
}
//----END----//

//Entry point function
void main() {
  //Run Example#1.
  createStreamUsingGenerators();
}

Output:

Source Code is available here- Example#1.

Using `Stream.fromIterable()`

In this approach, Stream.fromIterable() takes an array of numbers as argument, and create a Stream of numbers delivering one event/number at a time.

Example#2:

//Example#2. Creating Stream of numbers using  `Stream.fromIterable()` method

void createStreamFromIterable() {
  var numbers = [1, 2, 3, 4, 5];
  Stream stream = Stream.fromIterable(numbers);
  printStream(stream);
}

//Printing numbers/events of Stream (Listening to Stream)
printStream(Stream stream) {
  stream.listen((s) => print(s));
}
//----END----//

//Entry point function
void main() {
  //Run Example#2.
  createStreamFromIterable();
}

Output:

Source Code is available here- Example#2.

Retrieving Events From Stream

We'll see two ways to print the events/numbers for the stream(s) created above.

Using `listen`

In the above two examples, we printed events of a Stream using listen by adding subscription to the given stream. Let's print messages before starting and after stream is finished.

Example#3.

//Example#3. Accessing Stream using `listen`

void printStreamEventsUsingListen() {
  Stream stream = Stream.fromIterable([1, 2, 3, 4, 5]);
  print("Stream Starting");
  stream.listen(
    (s) => print(s),
  );
  print("Stream Finished");
}
//----END----//

//Entry point function
void main() {
  //Run Example#3.
  printStreamEventsUsingListen();
}

Output:

Stream Starting
Stream Finished
1
2
3
4
5

Source Code is available here- Example#3.

Using `await for`

Streams are iterated in a await for asynchronous for-loop. Streams are notified when there's last event arrives and await for-loop stops. Let's see an example that takes the events from the stream generated above and print those numbers in events.

Example#4.

//Example#4. Accessing Stream using `await for`

void printStreamEventsUsingAwaitFor() async {
  Stream stream = Stream.fromIterable([1, 2, 3, 4, 5]);

  print("Stream Starting");
  await for (var num in stream) {
    print(num);
  }
  print("Stream Finished");
}
//----END----//

//Entry point function
void main() {
  //Run Example#4.
  printStreamEventsUsingAwaitFor();
}

Output:

Stream Starting
1
2
3
4
5
Stream Finished

Source Code is available here- Example#4.

The difference between listen and await for is that in listen approach, code related to creating stream executed first, and then events are printed. In the await for approach, events are printed as they come. This approach is works better when there are finite number of events in a stream, and stream does finish.

Processing Stream Events

In this example, let's add the numbers delivered by stream and return the total. Let's call this new function addEvents(...). Events from Stream is accessed using await for, and added one by one. The addEvents(...) function needs to be marked with async because it uses await inside the function. This method returns Future<int>. This future is accessed from addNumbersInStream() function using await and prints the total on console.

Example#5.

//Example#5. Processing (Adding) Stream using `await for`

void addNumbersInStream() async {
  //Create a Stream consists of numbers
  Stream stream = Stream<int>.fromIterable([1, 2, 3, 4, 5]);

  var total = await addEvents(stream);
  print(total);
}

//Receiving events from Stream, adding and returning total
Future<int> addEvents(Stream<int> stream) async {
  var total = 0;
  await for (var num in stream) {
    total += num;
  }

  return total;
}
//----END----//

//Entry point function
void main() {
  //Run Example#5.
  addNumbersInStream();
}

Output:

Source Code is available here- Example#5.

Handling Errors in Streams

When error(s) occurred, a Stream can notify it as error event just like data event. Stream can notify error in one of these three ways:

Stream notifies first error event and stops. We'll see few examples of this case in this article.
Stream notifies multiple errors events.
Stream notifies error event(s) and continue delivering events.

Error Handling in `await for` block

An error event can be responded in try/catch block. Let's see one of the above case to handle one error event by putting await for loop in previous example inside try/catch block. To be able to see catch block respond to error event, we need to tweak createStream to throw Exception at some point. Assume error event occurs when accessing 5th number.

Example#6.

///Handling Exceptions (Code shared for listen and await for implementations)

//Generated Stream with numbers. Added exception on purpose for demonstration
Stream<int> createNumberStreamWithException(int last) async* {
  for (int i = 1; i <= last; i++) {
    if (i == 5) {
      throw new Exception("Demo exception when accessing 5th number");
    }
    yield i; //to be able to send spaced out events
  }
}

//Example #6. Handle Error in Stream using `await for`
void handlingExceptionUsingAwaitFor() async {
  var stream = createNumberStreamWithException(5);
  try {
    await for (var num in stream) {
      print(num);
    }
  } catch (e) {
    print(e);
  }
  print("Finished");
}
//----END----//

//Entry point function
void main() {
  //Run Example#6.
  handlingExceptionUsingAwaitFor();
}

Output:

1
2
3
4
Exception: Demo exception when accessing 5th number
Finished

Source Code is available here- Example#6.

Handling Errors using `listen()` method

This is the better way to handle errors when you want to handle multiple errors without exiting code at the encounter of first error.

Example#7.

///Handling Exceptions (Code shared for listen and await for implementations)

//Generated Stream with numbers. Added exception on purpose for demonstration
Stream<int> createNumberStreamWithException(int last) async* {
  for (int i = 1; i <= last; i++) {
    if (i == 5) {
      throw new Exception("Demo exception when accessing 5th number");
    }
    yield i; //to be able to send spaced out events
  }
}

//Example #7. Handle Error in Stream using `listen`
void handlingExceptionUsingListen() async {
  var stream = createNumberStreamWithException(5);
  stream.listen(
    (num) => print(num),
    onError: (e) => print(e),
    onDone: () => print("Finished"),
  );
}
//----END----//

//Entry point function
void main() {
  //Run Example#7.
  handlingExceptionUsingListen();
}

Output:

1
2
3
4
Exception: Demo exception when accessing 5th number
Finished

Source Code is available here- Example#7.

Summary

In this article, we learned about the Dart Streams. Streams are useful when we want to process events as they become available rather waiting for everything to return in one batch like Futures. In next article, we'll learn about the type of streams available in Dart.

References

Happy cooking with Dart and Flutter :)

Liked the article? Couldn't find a topic of your interest? Please leave comments or email me about topics you would like me to write! BTW I love cupcakes and coffee both :)

Futures: Asynchronous Programming with Dart

2020-05-20T00:00:00-04:00

Target Audience: Beginner

Introduction

This article is a part of three part series focused on asynchronous Programming with Dart. This article covers Futures in Dart to execute program asynchronously.

Part-1 (Current) Futures: Asynchronous Programming with Dart
Part-2 Streams: Asynchronous Programming with Dart
Part-3 Types of Streams: Asynchronous Programming with Dart

Checkout the YouTube video:

Futures

"Futures" are Future objects that represent the results of asynchronous operations. Asynchronous operations don't block the thread and their processing finishes at a later time. Asynchronous operations results are returned as Futures. Functions that do expensive work should use asynchronous model for executing their work. Future object is represented as Future<T>, where T is the type of results returned from the expensive operation.

Asynchronous operations in Dart can be achieved in two ways:

Using await and async
Using Future API.

`await` and `async`

The await and async keywords are used together. The function that supposed to be doing the expensive work is marked with keyword async. Inside the function, the expensive call is prefixed by keyword await. Program suspends when await is called or function return or reaches at the end of the function.

Let's see in following code snippet how async and await keywords are used. await can only be called in function which is marked/declared as async. Future keyword before the function makeDataCall() means that this function will be executing asynchronously and will be suspended when come across await.

// Expensive function could be a function that takes
// long time to process data and return results.
// Assume this function takes long time to return in real-world
String getExpansiveData() {
  return "I'm expansive data";
}

// This is the asynchronous function that makes the expensive
// data call and prints the results.
Future<void> makeDataCall() async {
  var data = await getExpansiveData();
  print(data);
}
//----END----//

//Entry point function
void main() {
  //Run Example#1.
  makeDataCall();
}

The makeDataCall() returns a Future of type void because there's nothing returned by this function. It simply prints the results using print() function.

Output:

I'm expansive data

Note: You can run this code in DartPad by copy and pasting above code as is.

Source Code is available here- Example#1.

Error Handling (Try/Catch Block)

In this section, we'll see how to handle exceptions thrown in the long running asynchronous operations. When await keyword is used, asynchronous call behaves like a synchronous one. In such cases, error handling for asynchronous and synchronous code is handled similar way.

The asynchronous call prefixed with await keyword is wrapped in a try/catch block. When an exception is thrown in the try block, the catch block executes its code.

Let's add the try/catch block in previous code, and see how it'll look like now. Let's name this function as makeDataCallWithException(). This function throws an Exception at purpose in try block to demonstrate the point here.

//Example#2. Demonstrating handling exception thrown in asynchronous operations

//Expansive operations ended up throwing exception
String getExpansiveDataWithException() {
  throw Exception("Error occurred in fetching data");
}

//Asynchronous function that makes the expensive data call
Future<void> makeDataCallWithException() async {
  try {
    await getExpansiveDataWithException();
  } catch (e) {
    print(e.toString());
  }
}
//----END----//

//Entry point function
void main() {
  //Run Example#2.
  makeDataCallWithException();
}

Output:

Exception: Error occurred in fetching data

Source Code is available here- Example#2.

Sequencing Function Calls

It's possible to control the order of execution of asynchronous functions using sequencing with help of await and async. Let's see how this is done in example below. In this example, there are three functions getDataA(), getDataB(), and getDataC(). We want them to execute one after another. The await keyword does exactly that. It executes the function synchronously until it comes across await, and wait there for it to finish before execute next line, in this case another await call.

//Example#3. Sequencing order of asynchronous calls

void getDataA() {
  print("dataA");
}

void getDataB() {
  print("dataB");
}

String getDataC() {
  return "dataC";
}

//Entry point function
Future<void> sequencingOperations() async {
  //Order matters.
  //Functions will execute in the order they were called.
  await getDataA();
  await getDataB();

  //getDataC() will execute first and will
  //pass its data into print() function
  print(await getDataC());
}
//----END----//

//Entry point function
void main() {
  //Run Example#3.
  sequencingOperations();
}

Output:

Each of the above methods will execute one by one starting from getDataA() and finishing executing getDataC().

dataA
dataB
dataC

Source Code is available here- Example#3.

`Future` API

Another way to execute asynchronous operations is to use Future API. In the Future API, the then() method is used to register a callback, which fires up on the completion of Future.

Let's see two variant of using Future API.

Future<String>: Future returning String data type .
Future<void>: Future returning void.

`Future<String>`

Example below transforms our earlier example code of await and async into a Future API implementation. Lookout for the use of then() in mainWithFutureAPI() function. In this example, Future is returning String.

//Using Future API (Future is returning String type)

//Future with String data is being returned.
//This function returns the instance of
//Future and not the actual data.
Future<String> makeDataCallFutureString() async {
  return await getExpansiveData();
}

// Assume this function takes long time to return in real-world.
String getExpansiveData() {
  return "I'm expansive data";
}


void mainWithFutureAPI() {
  var theFuture = makeDataCallFutureString();

  //then() is called at the instance of Future
  theFuture.then((value) {
    print(value);
  });
}
//----END----//


//Entry point function
void main() {
  //Run Example#4.
  mainWithFutureAPI();
}

Output:

I'm expansive data

Source Code is available here- Example#4.

`Future<void>`

Let's look at another example of Future API. In this example, Future doesn't return anything and looks like Future<void>. In such case, then() callback will use an unused argument, represented as _ by convention. Checkout the code snippet below to see it in action.

//Example#5. Using Future API (Future is returning void type)

// Assume this function takes long time to return in real-world.
String getExpansiveData() {
  return "I'm expansive data";
}

//Future doesn't return anything
Future<void> makeDataCallFutureVoid() async {
  await getExpansiveData();
}

void mainWithFutureAPIVoid() {
  var theFuture = makeDataCallFutureVoid();
  //then() uses underscore as unused argument.
  theFuture.then((_) {
    //_ is not used
    print("There's nothing to be printed here. Work is already done.");
  });
}
//----END----//

//Entry point function
void main() {
  //Run Example#5.
  mainWithFutureAPIVoid();
}

Output:

There's nothing to be printed here. Work is already done.

Source Code is available here- Example#5.

Error Handling - `Future` API

Future API uses chaining to handle exceptions. Error is caught and handled in catchError() block. The catchError() is chained with then() method.

// Example#6. Future API - Error Handling

// Assume this function takes long time to return in real-world.
String getExpansiveData() {
  return "I'm expansive data";
}

// Future with String data is being returned.
// This function returns the instance of
// Future and not the actual data.
Future<String> makeDataCallFutureAPIError() async {
  var data = await getExpansiveData();
  throw Exception("Error occurred in making data call: $data");
}

void mainWithFutureAPIError() {
  var theFuture = makeDataCallFutureAPIError();

  //Error is caught and handled in catchError block
  theFuture.then((value) {
    print(value);
  }).catchError((error) {
    print(error);
  });
}
//----END----//

// Entry point function
void main() {
  //Run Example#6.
  mainWithFutureAPIError();
}

Output:

Exception: Error occurred in making data call: I'm expansive data

Source Code is available here- Example#6.

Usage of `Future.wait()`

The Future.wait() is used when multiple asynchronous functions needs to be executed before calling another function. This could be useful when data from multiple sources/functions is needed to be able to take next step. In another version, we're using Future API to accomplish what we did using async & await in 'Example#3' above.

//Example#7. Using `Future.wait()`

Future<String> getData(data) {
  return data;
}

Future<String> getDataAFuture() async {
  return await getData("dataA");
}

Future<String> getDataBFuture() async {
  return await getData("dataB");
}

Future<String> getDataCFuture() async {
  return await getData("dataC");
}

mainWithFutureAPIWait() async {
  //Chaining Futures in order
  await Future.wait([
    getDataAFuture(),
    getDataBFuture(),
    getDataCFuture(),
  ])
      .then(
        (List responses) => print(responses),
      )
      .catchError((error) => print(error));
}
//----END----//

//Entry point function
void main() {
  //Run Example#7.
  mainWithFutureAPIWait();
}

Output:

[dataA, dataB, dataC]

Source Code is available here- Example#7.

Summary

In this article, we saw how to use Futures to perform asynchronous operations in Dart. We explored await/async and Future API approaches to do so. Futures are like promises, which return results whenever they are complete. However, there's another approach to access asynchronous events using Streams. Streams provide results as they come until processing is finished. We'll explore Streams in the next article.

References

Happy cooking with Dart and Flutter :)

Liked the article? Couldn't find a topic of your interest? Please leave comments or email me about topics you would like me to write! BTW I love cupcakes and coffee both :)

Dart Libraries (Part2)

2020-05-10T00:00:00-04:00

Introduction

This article covers part, library, and export directives. Checkout the Part-1 to learn few ways libraries are used in Dart. In addition to introducing above directives, we'll also be learning to restrict the visibility of a library's APIs.

Check out YouTube Video

Revisiting Setup

Let's revisit the sample libraries lib1 and lib2created in Part-1 for demonstration.

`lib1`

This library has APIs to calculate sum and difference of two integers.

Addition API: The int addition(int a, int b) calculates sum of two given integers and returns an integer.
Subtraction API: The int subtraction(int a, int b) calculates difference of two given integers and returns an integer.
int _add(int a, int b): It is an internal function/method that does perform the real addition. This method is used by addition api. Identifiers with underscore (_) prefix are only available inside library.

SourceCode: Please refer to lib1.dart

  int addition(int a, int b) => _add(a, b);

  int subtraction(int a, int b) => a - b;

  int _add(int a, int b) => a + b;

`lib2`

This library has APIs to check if the given number is even or odd.

Even number API (bool isNumberOdd(int num)): This api take a number and returns true if its even or vice versa.
Odd number API (bool isNumberOdd(int num)): This api take a number and returns true if its odd or vice versa.

SourceCode: Please refer to lib2.dart

  bool isNumberOdd(int num) => num.isOdd;

  bool isNumberEven(int num) => num.isEven;

Privacy (Restricting Access)

It's possible to restrict variables'/APIs visibility in Dart libraries. Identifiers with underscore (_) prefix are only available inside library.

Let's import lib1.dart to use addition(..) method. Please note that trying to call _add(...) method will show a compile time error since it's private and is available to lib1.dart only.

The lib_main.dart:

SourceCode: Please refer to lib_main.dart

import 'lib1.dart';

void main() {
  int num1 = 5;
  int num2 = 2;

  int sum = addition(num1, num2);
  print("Sum of $num1 and $num2 is $sum");

  //Compile-time error because _add() function is private
  //sum = _add(num1, num2);
}

Output:

Sum of 5 and 2 is 7

Using `part` directive

The use of part directive is most common in auto-generated code. Traditionally, part directive is a glue between two tightly coupled libraries.

Note: Related code is available in its own folder libraries/maths_part.

For example, lets that assume lib1.dart and lib2.dart are two huge libraries that were spilt into two. In normal circumstances, I would add both libraries in import statements at the top of maths_part/part_main.dart in order to access APIs from both libraries. In such scenarios, part directive could come handy to avoid multiple import statements.

The lib1.dart file: The part directive at the top mentions that all lib2 belongs to lib1, and bring-in all lib2's apis into lib1. Only importing lib1.dart will give access to both libraries' apis.

SourceCode: Please refer to lib1.dart

//importing lib1 brings-in all apis from lib2 as well
part 'lib2.dart';

int addition(int a, int b) => _add(a, b);

int subtraction(int a, int b) => a - b;

int _add(int a, int b) => a + b;

The lib2.dart file: This library is marked as part of lib1.dart by using part of directive as part of 'lib1.dart';.

SourceCode: Please refer to lib2.dart

part of 'lib1.dart';

bool isNumberOdd(int num) => num.isOdd;

bool isNumberEven(int num) => num.isEven;

The part_main.dart file: Importing lib1.dart gives access to all apis from both lib1 & lib2. part_main.dart

import 'lib1.dart';

void main() {
  int num1 = 5;
  int num2 = 2;

  //API from lib1.dart
  int sum = addition(num1, num2);
  print("Sum of $num1 and $num2 is $sum");

  //API from lib2.dart
  print("is number even? ${isNumberEven(num2)}");
}

Output:

Sum of 5 and 2 is 7
is number even? true

`library` directive

The library directive is used to auto-generate documentation for library using dartdoc tool.

SourceCode: Please refer to math_lib1 for this example.

Generating documentation

Add library directive at the top of lib1.dart:

library math_lib1;

Create a directory math_lib1, and copy lib1.dart under it.
Add pubspec.yaml under math_lib1 directory:

name: math_lib1
description: Math operations library
version: 0.0.1

Use dartdoc tool to create documentation:

  $ cd math_lib1

  # Generates documentation
  $ dartdoc

  # Documentation available at `http://localhost:8080/`
  $ dhttpd --path doc/api

Using `export` directive

This directive is used to export only public apis. In other words, it makes apis publicly accessible.

SourceCode: Please refer to math_export for this example.

The lib1.dart and lib2.dart files are available under lib/src/ folder. The files under lib/src/ directory are hidden. The lib/maths_export.dart file use export directive to make lib1.dart public.

The lib/maths_export.dart:

SourceCode: Please refer to maths_export.dart

export 'src/lib1.dart';

An external file lib_export.dart imports maths_export.dart like below:

The lib_export.dart:

SourceCode: Please refer to lib_export.dart

import 'math_export/lib/maths_export.dart';

void main() {
  int num1 = 5;
  int num2 = 2;

  int sum = addition(num1, num2);
  print("Sum of $num1 and $num2 is $sum");

  //Compile-time error because lib2.dart is not exported
  //print("is number even? ${isNumberEven(num2)}");
}

Output:

Sum of 5 and 2 is 7

Summary

In this article, we saw how can export, library, and part directives are used in Dart. We touched on generating documentation from Dart libraries. We also saw how to keep apis private in libraries.

That's it for this article. Check out the Dart Vocabulary Series for other Dart stuff.

Source Code

Please checkout the source code at Github here

References

Official Dart Language Tour

Happy Darting :)

_Liked the article ? Couldn't find a topic of interest? Please leave a comment or reach out at twitter about the topics you would like me to share!

BTW I love cupcakes and coffee both :)_

Follow me at Medium

Dart Libraries (Part1)

2020-05-09T00:00:00-04:00

Introduction

This article is an introduction to using libraries in Dart/Flutter. A library is a reusable module for frequently used programs/code. It helps to write modular code base. In Dart, each app is a library. This article is divided into two parts.

Part-1: This part covers how to use Dart libraries including following:

Using Prefix for library
Importing specific APIs
Defer/delay loading library

Part-2: The second part covers understanding following directives:

The part directive
The library directive
The export directive

Check out YouTube Video

Setup

Let's create two libraries lib1 and lib2 for demonstration.

`lib1`

This library has APIs to calculate sum and difference of two integers.

Addition API: The int addition(int a, int b) calculates sum of two given integers and returns an integer.
Subtraction API: The int subtraction(int a, int b) calculates difference of two given integers and returns an integer.
int _add(int a, int b): It is an internal function/method that does perform the real addition. This method is used by addition api. Identifiers with underscore (_) prefix are only available inside library.

SourceCode: Please refer to lib1.dart

  int addition(int a, int b) => _add(a, b);

  int subtraction(int a, int b) => a - b;

  int _add(int a, int b) => a + b;

`lib2`

This library has APIs to check if the given number is even or odd.

Even number API (bool isNumberOdd(int num)): This api take a number and returns true if its even or vice versa.
Odd number API (bool isNumberOdd(int num)): This api take a number and returns true if its odd or vice versa.

SourceCode: Please refer to lib2.dart

  bool isNumberOdd(int num) => num.isOdd;

  bool isNumberEven(int num) => num.isEven;

  //Added to demonstrate handle conflicting name in two different libraries
  int addition(int a, int b) => a + b + 2;

Using Prefix for library

Let's use lib1.dart to calculate addition of two numbers 5 and 2, and use lib2.dart to check if number 5 is even or odd. For lib2.dart, a prefix check is used. This is used to access lib2's APIs thereafter. All lib2's API's can be accessed using check alias.

The lib_prefix.dart:

SourceCode: Please refer to lib_prefix.dart

import 'lib1.dart';
import 'lib2.dart' as check; //Using prefix for lib2

void main() {
  int num1 = 5;
  int num2 = 2;

  int sum = addition(num1, num2);
  print("Sum of $num1 and $num2 is $sum");

  //Using check to access the API
  print("is number even? ${check.isNumberEven(num2)}");
}

Output:

Sum of 5 and 2 is 7
is number even? true

Handling Conflicts

Using prefix will only call method from respective library when more than one libraries have similar named apis.

The lib_conflict.dart:

SourceCode: Please refer to lib_conflict.dart

import 'lib1.dart';
import 'lib2.dart' as check;

void main() {
  int num1 = 5;
  int num2 = 2;

  int sum = addition(num1, num2);
  print("Sum of $num1 and $num2 is $sum");

  //Calls addition() from lib2
  sum = check.addition(num1, num2);
  print("Sum of $num1 and $num2 is $sum");
}

Output:

Sum of 5 and 2 is 7
Sum of 5 and 2 is 9

Importing specific APIs

Dart libraries allow to import only specific apis using show and hide keywords.

show:

The show is used when a specific API needs to be made visible/accessible. For example, in lib1.dart, I want to access only subtraction(...) API.

The lib_show.dart:

SourceCode: Please refer to lib_show.dart

import 'lib1.dart' show subtraction;

void main() {
  int num1 = 5;
  int num2 = 2;

  //Compile-time error because addition is no longer visible
  //int sum = addition(num1, num2);

  int difference = subtraction(num1, num2);
  print("Difference of $num1 and $num2 is $difference");
}

Output:

Difference of 5 and 2 is 3

hide:

The hide is used when everything but a specific API is made accessible/visible.

The lib_hide.dart:

SourceCode: Please refer to lib_hide.dart

import 'lib1.dart' hide subtraction;

void main() {
  int num1 = 5;
  int num2 = 2;

  int sum = addition(num1, num2);
  print("Sum of $num1 and $num2 is $sum");

  //Compile-time error because subtraction() API is hidden
  //int difference = subtraction(num1, num2);
  //print("Difference of $num1 and $num2 is $difference");
}

Output:

Sum of 5 and 2 is 7

Defer/delay loading library

A deferred library is loaded when it's actually used/needed. It's declared using deferred as <name> in import statement. The library uses loadLibrary() method to invoke itself. The loadLibrary() method returns a Future. That's why library invocation needs to be done in a async block.

The lib_deferred.dart:

SourceCode: Please refer to lib_deferred.dart

import 'lib1.dart' deferred as lib1;

void main() {
  int num1 = 5;
  int num2 = 2;

  delayedInvocation(num1, num2);
}

Future delayedInvocation(int num1, int num2) async {
  //Loads lib1 here
  await lib1.loadLibrary();
  int sum = lib1.addition(num1, num2);
  print("Sum of $num1 and $num2 is $sum");
}

Output:

Sum of 5 and 2 is 7

Summary

In this article, we saw few ways to use Dart libraries. We learned how to use prefix to refer to libraries in import statements, importing only specific libraries, and delaying loading libraries until they are needed.

That's it for this article. Check out the Dart Vocabulary Series for other Dart stuff.

Source Code

Please checkout the source code at Github here

References

Official Dart Language Tour

Happy Darting :)

_Liked the article ? Couldn't find a topic of interest ? Please leave a comment or reach out at twitter about the topics you would like me to share !

BTW I love cupcakes and coffee both :)_

Follow me at Medium

Persisting Data in Local DB for Flutter (Android & iOS)

2020-05-06T00:00:00-04:00

Target Audience: Beginner

Recipe: Persisting products data in local database using sqflite Flutter plugin.

Focus Widget: Flutter plugin sqflite.

Goal: In this recipe, we'll create, save, and retrieve two objects of custom data type, Product in the local sqlite database. We'll create two files for this recipe:

User Interface -ecom.dart : User interface to load data from local database.
Database -ecom_db.dart: This file contains all code related to sqlite database.

The user interface will load two demo products in a ListView as shown in this screenshot:

Flutter Cookbook

This code recipe is added in the Flutter Cookbook app as well. Source code link is available at the end of this article.

Checkout the YouTube video:

`pubspec.yaml` dependency

Add sqflite plugin dependency as below:

dependencies:
  flutter:
    sdk: flutter

  #Local database
  sqflite: ^1.3.0

Note: The sqflite plugin has dependency on path plugin. Please add this dependency it's not already present in your configuration file.

User Interface

In this code recipe, there're only two product items used for demonstration purposes. Each item has an image, title, description, and price.

The UI is composed of widgets as shown below:

Note: This article is not intended for learning to build user interface. Hence, I'll quickly review the UI structure. Please refer to source code to see full code.

Main interface is rendered using ListView widget. The ListView widget has a Column widget as its child. The custom widget positionedBlock() is added as Column widget's child.

positionedBlock(): This method returns interface for each item in the list. It's is aligned in topCenter using Align widget. A Stack widgets contains two Positioned widgets for product description and image. The first Positioned widget is added in the background to display product information (in a Column widget). The another Positioned widget contains the product's image.

The main screen is a StatefulWidget since we want to update data retrieved from local database. Sample data in database is added as soon as the app starts. We'll go over database details in next section. The initDB() method is called rom initState() method. The initState() method executes once during screen startup-time. We want to keep data ready in database for querying by build() method.

class ProductListing extends StatefulWidget {
  @override
  _ProductListingState createState() => _ProductListingState();
}

class _ProductListingState extends State<ProductListing> {
  @override
    void initState() {
      super.initState();
      //insert demo data
      initDB();
  }
}

Rendering Data from Database

The _ProductListingState widget's build() method is responsible for updating data at the interface. It uses FutureBuilder widget to render data returned from asynchronous methods like Future. Usually data is returned asynchronously from database or remote network operations. FutureBuilder widget helps render data asynchronously at user interface side.

body: FutureBuilder(
    //fetching products from db
    future: allProducts(),
    builder: (context, AsyncSnapshot snapshot) {
      if (!snapshot.hasData) {
        //loading circular progress bar
        return Center(child: CircularProgressIndicator());
      } else {
        return Container(
          child: ListView.builder(
            itemCount: snapshot.data.length,
            scrollDirection: Axis.vertical,
            itemBuilder: (BuildContext context, int index) {
              return Column(
                children: [
                  //custom widget
                  positionedBlock(context, snapshot.data[index]),
                  Divider(
                    thickness: 2,
                  ),
                ],
              );
            },
          ),
        );
      }
    }),

The allProducts() method returns a list of Product of Future type. Each product entry uses positionedBlock(...) method to display product details. Checkout the source code for this here.

Let's explore the database side of things next.

Local Database

The sqflite plugin access to sqlite database on Android and iOS devices for Flutter. Let's check out the database operations next.

Note: Refer ecom_db.dart.

Creating Database

The openDatabase() method takes database path, version of the database to support db upgrades & downgrades, and a way to create table using onCreate: attribute.

The getDatabasesPath() provides the physical location of database on device. The join() methods is a utility method to join the given paths into single path as per the current platform's file separator. You need path plugin to access join() method.

Future<Database> db() async {
  return openDatabase(
    join(await getDatabasesPath(), 'products_database.db'),
    onCreate: (db, version) {
      return db.execute(
        'CREATE TABLE IF NOT EXISTS $tableProducts(id INTEGER PRIMARY KEY, title TEXT, description TEXT, image TEXT, price REAL)',
      );
    },
    // Version provides path to perform database upgrades and downgrades.
    version: 1,
  );
}

The db() will return Database as Future. Initializing database is an asynchronous operation. The database reference is being held in database variable, and product table name is products and stored in tableProducts constant. A table products is created if doesn't exist already.

Product class

The Product is represented with class Product. A product object has id, title, description, image, and price.

class Product {
  final int id;
  final String title;
  final String description;
  final String image;
  final double price;

  Product({this.id, this.title, this.description, this.image, this.price});

  Map<String, dynamic> toMap() {
    return {
      'id': id,
      'title': title,
      'description': description,
      'image': image,
      'price': price,
    };
  }

  @override
  String toString() {
    return 'Product("id": ${this.id}, "title": ${this.title}, "description": ${this.description}, '
        '"image": ${this.image}, "price":${this.price});';
  }
}

Inserting Product

Inserting data into a table is an asynchronous operation as well. First get a reference to database and then pick a conflictAlgorithm. It is a rule to resolve conflicts. In our case, we want to replace old content with new content if record is already present. Hence, it makes sense to pick ConflictAlgorithm.replace conflictAlgorithm.

Future<void> insertProduct(Product product) async {
  // Get a reference to the database.
  final Database db = await database;

  // Insert the Product into the correct table.
  // Specify `conflictAlgorithm`.
  // In this case, if the same product is inserted
  // multiple times, it replaces the previous data.
  await db.insert(
    tableProducts,
    product.toMap(),
    conflictAlgorithm: ConflictAlgorithm.replace,
  );
}

Querying All Products

We want to render all products from the table into interface. In our case, there are only two products.

Future<List<Product>> allProducts() async {
  // Get a reference to the database.
  final Database db = await database;

  // Query the table for all The Products.
  final List<Map<String, dynamic>> maps = await db.query(tableProducts);

  // Convert the List<Map<String, dynamic> into a List<Product>.
  return List.generate(
    maps.length,
    (i) {
      return Product(
          id: maps[i]['id'],
          title: maps[i]['title'],
          description: maps[i]['description'],
          image: maps[i]['image'],
          price: maps[i]['price']);
    },
  );
}

Updating Product

In this code recipe, we're not editing an existing item. However, db.update(...) method is useful to update the items. Remember to make use of whereArgs to avoid SQL injections.

Future<void> updateProduct(Product product) async {
  // Get a reference to the database.
  final db = await database;

  // Update the given Product.
  await db.update(
    tableProducts,
    product.toMap(),
    // Ensure that the Product has a matching id.
    where: "id = ?",
    // Pass the Products's id as a whereArg to prevent SQL injection.
    whereArgs: [product.id],
  );
}

Deleting Product

We're not deleting any item either in this sample. Similar to update, remember to use whereArgs to keep SQL injections on the bay.

Future<void> deleteProduct(int id) async {
  // Get a reference to the database.
  final db = await database;

  // Remove the Product from the database.
  await db.delete(
    tableProducts,
    // Use a `where` clause to delete a specific product.
    where: "id = ?",
    // Pass the Products's id as a whereArg to prevent SQL injection.
    whereArgs: [id],
  );
}

Inserting Sample Data into Table

In our sample, we're creating following two products, and inserting into database using await keyword to keep it asynchronous. The product images are loaded from local assets folder.

void initDB() async {
  var prod1 = Product(
    id: 1,
    title: 'Shoes',
    description: 'Rainbow Shoes',
    image: 'shoes.jpeg',
    price: 65.0,
  );

  var prod2 = Product(
    id: 2,
    title: 'Dress',
    description: 'Summer Dress',
    image: 'dress.png',
    price: 50.0,
  );

  // Insert a product into the database.
  await insertProduct(prod1);

  await insertProduct(prod2);
}

That's all ! In this code recipe, we added two products in local database, and displayed both product entries in Flutter App.

Note: The sqflite plugin provides the lower level implementation for creating and accessing database on Android and iOS platforms. However, the moor plugin provides database access across Android, iOS and Web platforms. Please check out my article about persisting data using moor plugin.

Source Code Repo

Recipe source code is available here
Flutter Cookbook project's source code is available here

References

The path Plugin
The sqflite Plugin

Happy cooking with Flutter :)

_Liked the article ? Couldn't find a topic of your interest ? Please leave a comment or reach out at twitter about the topics you would like me to share !

BTW I love cupcakes and coffee both :)_

Follow me at Medium

Dart Generics

2020-04-30T00:00:00-04:00

Introduction

Generics are used to apply stronger type checks at compile time. They enforce type-safety in code. For example, in collections the type-safety is enforced by holding same type of data. Generics help write reusable classes, methods/functions for different data types.

Type Safety: Programming concept that allows a memory block to contain only one type of data.

The concept of Generics in Dart, is similar to Java's generics and C++'s templates.

Dart's collection can hold different data types in one collection. It's optional in Dart to mention data type for a value. Usually, the variable's data type is inferred automatically. For example, var myVar = 5; will infer myVar's dataType as int. The following code is valid in Dart:

void main() {
  List items = [1, "Empty", 1.0];
  print(items);
}

Output:

[1, Empty, 1.0]

Check out YouTube Video

Declaring Type-safe Collections

The angular brackets <>, with data type enclosed, is used to declare the collection of given data type to ensure type-safety.

Syntax:

CollectionType <dataType> identifier = CollectionType <dataType>();

Example:

List<int> numbers = List<int>();

Generics are parameterized and use type variables notations to restrict the type of data. These type variables are represented using single letter names. A few typically used single letter names are:

E: The letter E is used to represent the element type in a collection like List.
K: The letter K is used to represent the key type in associative collections like Map.
V: The letter V is used to represent the value type in associative collections like Map.
R: The letter R is used to represent the return type of a method or function.

You can also use a single letter of your choice or a descriptive word for parameter names / generics. Let's explore these two options in the following example.

///Example #1: Demonstrating use of single letter and descriptive words for generics

//A class for grocery product
class Product {
  final int id;
  final double price;
  final String title;
  Product(this.id, this.price, this.title);

  @override
  String toString() {
    return "Price of ${this.title} is \$${this.price}";
  }
}

//A class for product's inventory
class Inventory {
  final int amount;

  Inventory(this.amount);

  @override
  String toString() {
    return "Inventory amount: $amount";
  }
}

//Custom type variables- Single letter
class Store<P, I> {
  final HashMap<P, I> catalog = HashMap<P, I>();

  List<P> get products => catalog.keys.toList();

  void updateInventory(P product, I inventory) {
    catalog[product] = inventory;
  }

  void printProducts() {
    catalog.keys.forEach(
      (product) => print("Product: $product, " + catalog[product].toString()),
    );
  }
}

//Custom type variables- Descriptive
class MyStore<MyProduct, MyInventory> {
  final HashMap<MyProduct, MyInventory> catalog =
      HashMap<MyProduct, MyInventory>();

  List<MyProduct> get products => catalog.keys;

  void updateInventory(MyProduct product, MyInventory inventory) {
    catalog[product] = inventory;
  }

  void printProducts() {
    catalog.keys.forEach(
      (product) => print("Product: $product, " + catalog[product].toString()),
    );
  }
}

//Demonstrating single letter vs descriptive names for generics.
//Both variations have the same results.
void mainCustomParams() {
  Product milk = Product(1, 5.99, "Milk");
  Product bread = Product(2, 4.50, "Bread");

  //Using single letter names for Generics
  Store<Product, Inventory> store1 = Store<Product, Inventory>();
  store1.updateInventory(milk, Inventory(20));
  store1.updateInventory(bread, Inventory(15));
  store1.printProducts();

  //Using descriptive names for Generics
  MyStore<Product, Inventory> store2 = MyStore<Product, Inventory>();
  store2.updateInventory(milk, Inventory(20));
  store2.updateInventory(bread, Inventory(15));
  store2.printProducts();
}

Output:

Product: Price of Bread is $4.5, Inventory amount: 15
Product: Price of Milk is $5.99, Inventory amount: 20
Product: Price of Bread is $4.5, Inventory amount: 15
Product: Price of Milk is $5.99, Inventory amount: 20

Code Re-use

Generics help to write re-usable code. Generics for classes and methods enable reusing same code for different implementations of data types. Let's explore the details below.

Generics Methods / Functions

Let's define a method lastItem() which take the list of products, and returns the last item in the list. In this method, parameter T is returned, a list of type T elements is passed to method, and T type is stored in variable last.

In mainGenericMethods() method, there are two different data types are using lastItem() method to retrieve last item in their respective lists. First list is made up of Product items. Second list is made up of int data type. The T lastItem<T>(List<T> products) method using generic T parameter to support multiple data types using the same method. This is one excellent example of writing reusable functions/class methods.

//Example #2: Generics methods

//Function's return type (T).
//Function's argument (List<T>).
//Function's local variable (T last).
T lastItem<T>(List<T> products) {
  T last = products.last;
  return last;
}

mainGenericMethods() {
  Store<Product, Inventory> store = Store<Product, Inventory>();
  Product milk = Product(1, 5.99, "Milk");
  Product bread = Product(2, 4.50, "Bread");
  store.updateInventory(milk, Inventory(20));
  store.updateInventory(bread, Inventory(15));

  //Data type of `Product` is being used
  Product product = lastItem(store.products);
  print("Last item of Product type: ${product}");

  //Demonstrating using another type of data on same `lastItem()` method.
  List<int> items = List<int>.from([1, 2, 3, 4, 5]);
  int item = lastItem(items);
  print("Last item of int type: ${item}");
}

Output:

Last item of Product type: Price of Bread is $4.5
Last item of int type: 5

Generics Classes

Generic classes help to restrict the type of values accepted by the class. These supplied values are known as generic parameter(s). In the following example, class FreshProduce is restricted to accept only Product dataType. It's okay to use FreshProduce without <Product> parameter, and it will assume it as of type Product. However, if any other data type other than allowed type is passed, you'll see the compile time error.

///Example #3: Using Generics for classes

//Restricting the type of values that can be supplied to the class.
//FreshProduce class can only accept of Product type when T extends Product
class FreshProduce<T extends Product> {
  FreshProduce(int i, double d, String s);

  String toString() {
    return "Instance of Type: ${T}";
  }
}

mainGenericClass() {
  //Using `Product` parameter accepted by FreshProduce class
  FreshProduce<Product> spinach = FreshProduce<Product>(3, 3.99, "Spinach");
  print(spinach.toString());

  //Passing
  FreshProduce spinach2 = FreshProduce(3, 3.99, "Spinach");
  print(spinach2.toString());

  //This code will give compile time error complaining that Object is not of type Product
  //FreshProduce<Object> spinach3 = FreshProduce<Object>(3, 3.99, "Spinach");
  //print(spinach3.toString());
}

Output:

Instance of Type: Product
Instance of Type: Product

Generic collections

In this section, let's checkout the type-safe implementations for some of the Dart's collection literals:

List
Queue
Set
Map

List

In this example, a list of int datatype is constructed using parameterized constructor - another example of using generics. Additionally, two more items are added to list.

Now, adding a dataType other than int will throw a compile time error. Copy this code in Dart Pad , and uncomment theList.add(4.0); to see compile time error yourself.

void mainList() {
  //using parameterized types with constructors
  List<int> theList = List<int>.from([1]);
  theList.add(2);
  theList.add(3);

  //Adding double data type will throw compile time error
  //theList.add(4.0);

  //iterate over list and print all items
  print("Printing items in Dart List");
  for (int item in theList) {
    print(item);
  }
}

Output:

Printing items in Dart List
1
2
3

Queue

In this example, a queue of double datatype is constructed using parameterized constructor - another example of using generics. Additionally, two more items are added to the queue. Adding a different dataType String will throw a compile time error.

void mainQueue() {
  //using parameterized types with constructors
  Queue<double> theQueue = Queue<double>.from([1.0]);
  theQueue.add(2.0);
  theQueue.add(3.0);

  //Adding String data type will throw compile time error
  //theQueue.add("4.0");

  print("Printing items in Dart Queue");
  //iterate over queue and print all items
  for (double item in theQueue) {
    print(item);
  }
}

Output:

Printing items in Dart Queue
1.0
2.0
3.0

Set

In this example, a set of String datatype is constructed using parameterized constructor - another example of using generics. Additionally, two more items are added to the set. Adding a different dataType int will throw a compile time error.

void mainSet() {
  Set<String> theSet = Set<String>.from({"1"});
  theSet.add("2");
  theSet.add("3");

  //Adding int data type will throw compile time error
  //theSet.add(3);

  print("Printing items in Dart Set");
  //iterate over set and print all items
  for (String item in theSet) {
    print(item);
  }
}

Output:

Printing items in Dart Set
1
2
3

Map

In this example, a Map of String datatype is constructed using parameterized constructor - another example of using generics. One more item is added to the Map. Adding a different dataType int will throw a compile time error.

void mainMap() {
  Map<int, String> theMap = {1: 'Dart'};
  theMap[2] = 'Flutter';

  //Adding int data type for String value will throw compile time error
  //theMap[3] = 3;

  print("Printing key:value pairs in Dart Map");
  //iterate over map and print all entries
  for (MapEntry mapEntry in theMap.entries) {
    print("${mapEntry.key} : ${mapEntry.value}");
  }
}

Output:

Printing key:value pairs in Dart Map
1 : Dart
2 : Flutter

Summary

In this article, we learned how to use generics in Dart. We saw how generics can be useful in writing type-safe and reusable code.

That's it for this article. Check out the Dart Vocabulary Series for other Dart stuff.

Source Code

Please checkout the source code at Github here

References

Happy Darting :)

_Liked the article? Couldn't find a topic of your interest? Please leave a comment or reach out at twitter about the topics you would like me to share!

BTW I love cupcakes and coffee both :)_

Follow me at Medium

Dart `static` keyword

2020-04-22T00:00:00-04:00

Introduction

In Dart language, the static keyword is used to declare class level variables and methods. A class level variable is useful to declare constants and implement the class-wide state.

The class methods can be called from other classes using class name they are defined in.

Usually, utility classes use static variables and methods to provide easy and quick access to methods and constants.

Using `static` keyword

Let's take an example of a string utility class, say StringUtils. This class contains a convenience method, say reverse(String str), to reverse the given string . This utility class has a constant dart which is inferred to contain a String value of "oh dart".

class StringUtils {
  static const dart = "oh dart";

  static String reverse(String str) {
    return String.fromCharCodes(str.runes.toList().reversed);
  }
}

Note: In case you're interested in learning about runes used in code above to reverse the string, then check out my article on Runes.

Running Code

The class level variable can be accessed using class name. In code below, StringUtils is needed to access either constant dart or static method reverse(...).

void main() {
  String reversedStatic = StringUtils.reverse(StringUtils.dart);
  print(reversedStatic);
}

Output:

trad ho

Few Facts about Static Variables

Static variables are not initialized until they're used.
Useful for representing class state and constants.
Constants names are declared using lowerCamelCase convention.

Few Facts about Static Methods

Static / Class methods don't have access to this keyword.
Static methods can be used as compile-time constants, and can be passed as parameters to constant constructor. Let's create a class SomeObj with a const constructor:

class SomeObj {
  final String myStr;

  const SomeObj(this.myStr);
}

Running Code

Now the static method reverse(...) is passed as parameter to const SomeObj(...) constructor.

void main() {
  SomeObj obj = SomeObj(StringUtils.reverse(StringUtils.dart));
  print(obj.myStr);
}

Output:

trad ho

Tip

Dart supports top-level variables, constants, and methods. Usually utility methods are put together in a class of static methods.

In Dart, if such utility methods are not logically related, then they shouldn't be put inside a class. Such Methods can be put at top-level in a dart file.

The above static utility variable / methods can be moved to top-level. You don't need a class for namespace purposes. It's recommended to create a library instead for grouping methods according to namespaces.

//Utility method at top-level
const dart = "oh dart";

String reverse(String str) {
  return String.fromCharCodes(str.runes.toList().reversed);
}

Running Code

void main() {
  //Moving utility method/variable to top-level
  String reversedStr = reverse(dart);
  print(reversedStr);
}

Output:

trad ho

Note: Avoid classes with only static members in it as per this lint rule.

Summary

In this article, you learned how to use static keyword in Dart language. You learned facts about class variables and methods, and alternate implementations for utility classes without using static keywords.

Check out the Dart Vocabulary Series for other Dart stuff.

Check out YouTube Video

Source Code

Please checkout the source code at Github here

References

Happy Darting :)

_Liked the article? Couldn't find a topic of your interest? Please leave a comment or reach out at twitter about the topics you would like me to share!

BTW I love cupcakes and coffee both :)_

Follow me at Medium

Dart Mixins

2020-04-20T00:00:00-04:00

Introduction

Mixins keep Dart code reusable across separate classes. It's the most efficient way to reuse common code from multiple classes that share common behaviors.

A mixin class contains methods to be used by other classes without being their parent. This is how mixins differ from interfaces and abstract classes.

Mixins are declared using keyword mixin like below:

mixin SharedBehavior {

}

Let's understand this with help of the example of different people with different occupations: artist, engineer, doctor, and sportsman. Let's think in terms of OOP manner, representing people in their classes.

Person class: The most common properties could be abstracted in class Person that other classes would extend from. Common properties (like age , name etc) and common behaviors (like eat and sleep) can go in here.

abstract class Person {
  int age;
  int name;

  eat() {}
  sleep() {}
}

Artist class: Our artist is a Person. Makes landscapes sketches.
Engineer class: The engineer is a Person. Makes buildings sketches and reads research papers on construction.
Doctor class: The doctor is a Person. Reads daily on latest health news and likes to do workout.
Boxer class: The boxer is a type of Athlete. Athlete is a Person. Boxer does routine exercises as well practices punches.

As we see from above that artist does sketching. Engineer does sketching as well as reading. Doctor does reading and exercise. The athlete does exercise. The boxer-a type of athlete, also does boxing.

Let's see a visual representation in diagram below:

Such overlapping common behaviors can be extracted into mixins. Let's create mixins next.

Creating Mixins

Sketching

The Sketching mixin defines the common sketch() method. It takes a message and prints it on console to keep things simple for demonstration.

mixin Sketching {
  sketch(String message) {
    print(message);
  }
}

Reading

The Reading mixin defines dailyReading(String topic) method. A reading topic is passed as parameter.

mixin Reading {
  dailyReading(String topic) {
    print("Daily reading on ${topic}");
  }
}

Exercise

The Exercise mixin defines methods for running and weight training. The running(int mile) method passes mile parameter to print the message. The weightTraining(int weights) method prints the value for weights parameter.

mixin Exercise {
  running(int mile) {
    print("Daily run of ${mile} mile(s)");
  }

  weightTraining(int weights) {
    print("Lifting ${weights} lbs");
  }
}

Boxing

The Boxing mixin defines practicing punches behavior of an athlete. As per our requirements, only athletes are allowed to practice punches. In such cases, we may want to restrict the usage of mixin only by classes of type Athlete. We can apply such restriction on Boxing mixin by using on keyword followed by the Athlete - the class which is allowed the usage.

mixin Boxing on Athlete {
  punch(int n) {
    print("Boxer practicing ${n} punches");
  }
}

Using Mixins

In this section, you'll see examples of using mixins defined earlier.

`Artist` class

The artist makes landscapes sketches. It defines sketchLandscape() to do so. This method calls sketch(...) method from Sketching mixin.

class Artist extends Person with Sketching {
  sketchLandscape() {
    sketch("Making landscapes sketches");
  }
}

`Engineer` class

The engineer does make building sketches and reads research on building construction. The sketchBuildings() method uses sketch() method from Sketching mixin. The readResearchPaper() calls dailyReading(topic) from Reading mixin.

class Engineer extends Person with Sketching, Reading {
  sketchBuildings() {
    sketch("Sketching engineering drawings");
  }

  readResearchPaper() {
    String topic = "Building Construction";
    dailyReading(topic);
  }
}

`Doctor` class

The doctor reads health reports and does workouts to keep it. The readReports() method uses Reading mixin. The workout() method uses Exercise mixin to carve personalized workout plan.

class Doctor extends Person with Reading, Exercise {
  readReports() {
    String topic = "covid";
    dailyReading(topic);
  }

  workout() {
    running(1);
    weightTraining(10);
  }
}

`Athlete` class

The athlete is a person as well like other people we discussed so far. All athletes do their exercise, and have a general workout routine. The method generalRoutine() provide the general workout routine definition.

class Athlete extends Person with Exercise {
  generalRoutine() {
    running(2);
    weightTraining(20);
  }
}

`Boxer` class

The boxer is a Athlete who does boxing. The Boxing mixin provides the punch() to define punchPractice() method for boxer. The routineExercise() method defines exercise routine for this specific athlete with help of Exercise mixin.

class Boxer extends Athlete with Boxing {
  punchPractice() {
    punch(100);
  }

  routineExercise() {
    running(4);
    weightTraining(40);
  }
}

Running Code

In this section, let's run all the methods for each class.

void main() {
  print("Artist");
  Artist artist = Artist();
  artist.sketchLandscape();

  print("\nEngineer");
  Engineer engineer = Engineer();
  engineer.sketchBuildings();
  engineer.readResearchPaper();

  print("\nDoctor");
  Doctor doctor = Doctor();
  doctor.readReports();
  doctor.workout();

  print("\nBoxer");
  Boxer boxer = Boxer();
  boxer.punchPractice();
  boxer.routineExercise();
}

Output:

Artist
Making landscapes sketches

Engineer
Sketching engineering drawings
Daily reading on Building Construction

Doctor
Daily reading on covid
Daily run of 1 mile(s)
Lifting 10 lbs

Boxer
Boxer practicing 100 punches
Daily run of 4 mile(s)
Lifting 40 lbs

Summary

In this article, we learned what Mixins are used for and how to use them to share common code across classes. We learned that inheritance is used when there's is a type of relationship. Mixins are used to share code for common behaviors across unrelated classes.

Check out the Dart Vocabulary Series for other Dart stuff.

Check out YouTube Video

Source Code

Please checkout the source code at Github here

References

Happy Darting :)

_Liked the article ? Couldn't find a topic of your interest ? Please leave a comment or reach out at twitter about the topics you would like me to share !

BTW I love cupcakes and coffee both :)_

Follow me at Medium

Dart Enums

2020-04-14T00:00:00-04:00

Introduction

Enumerated Types (a.k.a Enums) were added as an experimental feature in Dart 1.8 release. Enums are like a class that represents a fixed number of constant values.

Imagine that you're working on a weather application, and you need a way to represent different states for weather. For example, weather can be sunny, cloudy or rainy. Now, you have two ways to represent these states in your code.

Using Constants

You can represent each state using a const keyword.

const SUNNY = 'Sunny';
const CLOUDY = 'Cloudy';
const RAINY = 'Rainy';

Using Enumerated Types

Another way to represent the same information is to use enumerated types using the enum keyword.

enum Weather {
  sunny,
  cloudy,
  rainy,
}

Use UpperCamelCase for enums like Weather.

Use lowerCamelCase for enum values. For example: sunny, cloudy, and rainy.

In the following section, let's explore the cases where using Enums make more sense.

Switch

In switch block, constants behave differently than enums.

Using Constants

When different type of weather state is represented using const, it's okay with switch block to declare case block for one constant. default block is optional as well. There's no compilation error when only one case block for sunny is declared, without default block.

//Using constants to display weather information
void mainSwitchConstants() {
  const SUNNY = 'Sunny';
  const CLOUDY = 'Cloudy';
  const RAINY = 'Rainy';

  //#1. Switch doesn't complain for const, but raise error for enums
  var choice = SUNNY;
  switch (choice) {
    case SUNNY:
      print("Sunny weather today");
      break;
  }
}

Output:

Sunny weather today

Using Enums

The switch block for enums requires case blocks for all of the enum class Weather members. The default block is required when case blocks for all enumerated type members are not available. Otherwise, you would see the compilation error like below:

Here's switch block with case blocks for all enum members:

//Using Enums to display weather information
void mainSwitchEnums() {
  var weather = Weather.sunny;

  //Following code will complain about
  // not including other types of weather
  //OR use default
  switch (weather) {
    case Weather.sunny:
      print("Sunny weather today!");
      break;
    case Weather.cloudy:
      print("Cloudy today!");
      break;
    case Weather.rainy:
      print("Rainy and gloomy weather.");
      break;
  }
}

Output:

Sunny weather today!

Check out the switch block when there's only default block is available. It prints the value of the current enum weather.

//Only default case. No compilation issue
void mainSwitchEnumsDefault() {
  var weather = Weather.sunny;

  switch (weather) {
    default:
      print("Current weather:${weather}");
  }
}

Output:

Current weather:Weather.sunny

Iterating

The another reason to use enums over constants could be to iterate over all the different types of weather. For constants, you would need a list to store all values, and then iterate over that list. However, for enums, all the members of enums can be listed using Weather.values. Let's print all the members of Weather enumerated type.

void mainIterating() {
  //#2. enums can iterate on all types at once.
  //No need to create a list of const
  Weather.values.forEach((w) => print(w));
}

Output:

Weather.sunny
Weather.cloudy
Weather.rainy

Enums extension

Enumerated types are supported by extensions. Check out my previous article on Dart Extensions here. Let's add an extension method console() to print index of enum and a custom message about along with it.

extension WeatherExt on Weather {
  //custom message for each weather type
  static const weatherMap = {
    Weather.sunny: "What a lovely weather",
    Weather.cloudy: "Scattered showers predicted",
    Weather.rainy: "Will be raining today",
  };

  //prints enum index and custom message
  void console() {
    print("${this.index} ${this.about}");
  }

  //about property returns the custom message
  String get about => weatherMap[this];
}

Next, iterate over all the members, and use extension method console() to print the custom message for each weather type.

void mainExtension() {
  //#3. Enum extensions. Using extension method console
  Weather.values.forEach((w) => w.console());
}

Output:

0 What a lovely weather
1 Scattered showers predicted
2 Will be raining today

Summary

In this article, we saw how enums can be a better choice over constants. We also learned to iterate over enums and using extensions for enumerated types.

That's it for this article. Check out the Dart Vocabulary Series for other Dart stuff.

Check out Video

Source Code

Please checkout the source code at Github here

References

Happy Darting :)

_Liked the article ? Couldn't find a topic of your interest ? Please leave a comment or reach out at twitter about the topics you would like me to share !

BTW I love cupcakes and coffee both :)_

Follow me at Medium

Dart Extensions

2020-04-07T00:00:00-04:00

Introduction

Dart Extensions were first introduced in Dart 2.6 as preview. Later on, they have been released in Dart 2.7 officially. The extensions feature is the way to add functionality to existing libraries.

Sometimes you may want to add utility method(s) in a third-party library or in a core class like String for your convenience. However, it may not be possible to add your methods in those classes all the time. The closest possible solution is to write utility and/or wrapper classes with static methods and members. These extra classes can bloat your code base and increases the number of objects in general.

In such scenarios, extensions feature can come handy. It may look like wrapper classes, but they are different than wrapper classes. In wrapper classes, object is explicitly passed as arguments to the static methods. However, extensions implicitly extends the type.

There are three types of Dart extensions :

Extension methods
Extension operators
Extension properties

Defining Extensions

In Dart, all three types of extensions are defined inside one code block. The code block starts with extension followed by an optional name for the extension and on keyword, and then the type.

For example, if I want to add a custom functionality to List data type, then the extension code block would look like below:

extension<T> MyList on List<T> {
  //extension methods

  //extension operators

  //extension properties
}

The MyList is optional. It's only needed when extensions are written in a separate file, and are being imported into another dart file. However, if you have another similar local / private extension, you might see conflicts. To avoid such conflicts, you may want to hide external extension like below:

//extensions2.dart has MyList extension definition
import 'extensions2.dart' hide MyList;

In the following section, let's explore few examples to use it.

Usage

Let's get started by defining a local extension<T> block on List<T> type. We'll be exploring different type of data types, so using generic type T.

extension<T> on List<T> {
  //extension methods

  //extension operators

  //extension properties
}

Extension Methods

In this section, we'll add two extension methods. We've a list of prices.

#1. Extension:

First, let's add an extension method priceList() to return the prices listing. This method doesn't do anything important, but demonstrate how extensions implicitly extends the type using this.

extension<T> on List<T> {
  //Extension Method: demo
  List<T> priceList() => this.map((item) => item).toList();

}

Using:

void main() {
  //List of prices
  List prices = [1, 1.99, 4];

  print("Price listing:");

  //priceList() is being called on `prices`
  print(prices.priceList());
}

Output:

Price listing:
[1, 1.99, 4]

#2. Extension:

The priceLabels(String symbol) extension method iterates over the price listing, and append a symbol prefix for each price.

extension<T> on List<T> {

  //Extension Method: Adding $ prefix
  List<String> priceLabels(String symbol) =>
      this.map((item) => "$symbol ${item}").toList();

}

Using:

void main() {
  //List of prices
  List prices = [1, 1.99, 4];

  print("\nPrice listing with \$ prefix");

  //The $ symbol is passed
  print(prices.priceLabels("\$"));
}

Output:

Price listing with $ prefix
[$ 1, $ 1.99, $ 4]

Extension Operators

In this section, we'll add two extension operators. We've a list of prices similar to last example.

#3. Extension:

Let's define an operator extension for ^ operator. I want to use this operator to increases the price by the n times, where n is the argument passed into it.

extension<T> on List<T> {
  //Extension Operator: Hike up the price by n
  List<num> operator ^(int n) =>
    this.map((item) => num.parse("${item}") * n).toList();

}

Using:

void main() {
  //List of prices
  List prices = [1, 1.99, 4];

  print("\nPrice listing after hiking up prices 3x of the original value");

  //argument is passed after the operator sign
  print(prices ^ 3);
}

Output:

Price listing after hiking up prices 3x of the original value
[3, 5.97, 12]

#4. Extension:

Next define another operator extension for - operator. I want to use this operator to reduce the items' price to half when this operator is used.

extension<T> on List<T> {
  //Extension Operator: Reduce all prices by half
   List<num> operator -() =>
       this.map((item) => num.parse("${item}") / 2).toList();
}

Using:

void main() {
  //List of prices
  List prices = [1, 1.99, 4];

  print(
      "\nSale Price listing: prices are reduced by half of the original value");

  //no-arg operator is put before the list variable
  print(-prices);
}

Output:

Sale Price listing: prices are reduced by half of the original value
[0.5, 0.995, 2.0]

Extension Property

In this section, we'll add one extension property. We've a list of prices similar to last example.

#5. Extension:

In this extension, we'll add a property to return total number of printed price tags needed for price listing, where 3 tags are needed per item. We've a list of prices similar to last example.

extension<T> on List<T> {
  //Extension Property: 3 printed labels for each price.
  int get numPrintedPriceTags => length * 3;
}

Using:

void main() {
  //List of prices
  List prices = [1, 1.99, 4];

  print("\nNumber of total price tags");
  print(prices.numPrintedPriceTags);
}

Output:

Number of total price tags
9

Companion Video

Source Code

Please checkout the source code at Github here

References

Happy Darting :)

_Liked the article ? Couldn't find a topic of your interest ? Please leave a comment or reach out at twitter about the topics you would like me to share !

BTW I love cupcakes and coffee both :)_

Follow me at Medium

The `runes` Property

2020-04-05T00:00:00-04:00

Background

In the digital world, all characters, numbers or symbols are represented using a unique numeric value, known as Unicode. The Unicode standard provides three distinct encoding forms for Unicode characters: UTF-8 (using 8-bit), UTF-16 (16-bit), and UTF-32 (32-bit units). Data is converted in one of these encoding during data transfer. In this article, we'll explore Dart language's one of the String class property known as runes to retrieve this encoded data.

What is `runes` Property?

In Dart, a string is represented using sequence of UTF-16 known as code units. A code unit is the number of bits used by the given encoding.

Code Point: A character in a string is represented by one or more code point(s). One code point is represented by one or more code units.

Code Unit: A code unit is the number of bits used by an encoding. For UTF-16 encoding, it uses two bytes.

The runes property returns an iterable of Unicode code-points of this string of Runes type. The Runes is the integer representation for unicode code points of a String.

Usage

The String Class has following methods to access runes for a String.

The `codeUnitAt` Method

This method returns the UTF-16 (16-bit) code unit at the given index for the String.

  String myStr = "Mask";

  ///Code unit at 0th position is M.
  ///UTF-16 decimal representation for ASCII character 'M' is 77
  ///Reference: https://www.fileformat.info/info/unicode/char/004d/index.htm
  print("Code Unit for Letter M: ${myStr.codeUnitAt(0)}");

Output:

Code Unit for Letter R: 77

The `codeUnits` Property

This property provides an unmodifiable list of the UTF-16 code unit(s) of this string.

  String myStr = "Mask";
  print("Code Units for word Mask: ${myStr.codeUnits}");

Output:

Code Units for word Mask: [77, 97, 115, 107]

The `runes` Property

This property returns the list of Unicode UTF-16 code point(s) for the given string. In this case, code points are same as of code units. The myStr.runes returns the Iterable<int>.

  String myStr = "Mask";
  print("Runes for word Mask: ${myStr.runes}");

Output:

Runes for word Mask: (77, 97, 115, 107)

Example

Let's use hex representation for word "Mask". Hex for "M" is "004D", "A" is "0061", "S" is "0073", and "K" is "006B".

//Representing Mask in hex
String hexStr = "\u004D\u0061\u0073\u006B";
print("From hex to String - maskStr: ${hexStr}");

Runes codeUnits = Runes(hexStr);
print("Code Units: ${codeUnits}");
print("Code Units To String: ${String.fromCharCodes(codeUnits)}");

Output:

From hex to String - maskStr: Mask
Code Units: (77, 97, 115, 107)
Code Units To String: Mask

Example

Let's try another example to get runes for a symbol represented using 32-bit, using unicode character for mask emoji.

//Unicode character encoding : https://www.compart.com/en/unicode/U+1F637
//Decimal representation : 128567
String smileyMask = "\u{1F637}"; //needs 32 bit
print("Smiley with mask: ${smileyMask}");

// Prints Code Points for smiley with mask
print("Code Points in smily with mask: ${smileyMask.runes}");

//Printing String for code points
print(String.fromCharCodes(Runes(smileyMask)));

Output:

Smiley with mask: 😷
Code Points in smily with mask: (128567)
😷

Companion Video

Source Code

Please checkout the source code at Github here

References

Happy Darting :)

_Liked the article ? Couldn't find a topic of your interest ? Please leave a comment or reach out at twitter about the topics you would like me to share !

BTW I love cupcakes and coffee both :)_

Follow me at Medium

The `runtimeType` Property

2020-04-02T00:00:00-04:00

What is `runtimeType` Property ?

The runtimeType property is used to find out the runtime type of the object. The keyword var in Dart language lets a variable store any type of data. The runtimeType property helps to find what kind of data is stored in the variable using var keyword. In the next section, we'll explore usage of this property in for different type of data.

Usage

Let's see a few examples of using runtimeType property below. You can execute code samples in DartPad online.

The keyword var in Dart lets a variable store any type of data. Depending on what type of data is stored, it infers the data type. Calling runtimeType on the variable will return the data type of the variable.

int: Find the type of the variable storing an integer value. An integer in dart is represented using int class.

In this examples, variable myNumber is storing an integer. Calling runtimeType on this variable will return the data type of the variable as int.

//Variable myNumber is storing an integer value
var myNumber = 1;

//myNumber.runtimeType will print the data type for the variable
print("Type of myNumber: ${myNumber.runtimeType}");

Output:

Type of myNumber: int

String: Find the type of the variable storing a string value.

In this examples, variable myString is storing a string. Calling runtimeType on this variable will return the data type of the variable as String.

//Variable myString is storing an string value
var myString = "This is String";

//myString.runtimeType will print the data type for the variable
print("Type of myString: ${myString.runtimeType}");

Output:

Type of myString: String

double: Find the type of the variable storing a double value.

In this examples, variable myDouble is storing a double. Calling runtimeType on this variable will return the data type of the variable as double.

//Variable myDouble is storing an string value
var myDouble = 1.0;

//myDouble.runtimeType will print the data type for the variable
print("Type of myDouble: ${myDouble.runtimeType}");

Output:

Type of myDouble: double

List<int>: Find the type of the variable storing a list of integers.

In this examples, variable myList is storing a list of integers. Calling runtimeType on this variable will return the data type of the variable as List<int>.

//Variable myList is storing an string value
var myList = [1, 2, 3];

//myList.runtimeType will print the data type for the variable
print("Type of myList: ${myList.runtimeType}");

Output:

Type of myList: List<int>

Companion Video

Source Code

Please checkout the source code at Github here

References

Happy Darting :)

_Liked the article ? Couldn't find a topic of your interest ? Please leave a comment or reach out at twitter about the topics you would like me to share !

BTW I love cupcakes and coffee both :)_

Follow me at Medium

Building Cross-Platform Finger Painting App in Flutter

2020-03-31T00:00:00-04:00

Target Audience: Beginner

Recipe: In this code recipe, you'll use canvas painting to build a Finger Painting App in Flutter.

Focus Widget(s): GestureDetector, CustomPaint

Goal: We'll implement the following items in this Finger Painting Flutter App :

Drawing / Painting Area: This is the main area of the screen where an image can be displayed to color or draw more details to it.

Action Items: A Floating Action Button (FAB) menu to store all the menu items to make color, stroke, and opacity selections.

Flutter Cookbook:

This code recipe is added to Flutter Cookbook as well:

Checkout the companion video tutorial:

Drawing / Painting Area

Let's go ahead with building main area of the finger painting app. In this app, a picture of hut is displayed as background to color in. User can color this page while adding more details to the picture using tools provided by the app.

We'll be using 'StatefulWidget' to implement the app. This is because we need to convert the user's tap into drawing/painting while updating the finger movement on the screen.

Note: You can either choose to run this sample from main() method or invoke it from Flutter Cookbook app as mentioned above.

//Optional app's entry point. Uncomment if running only this file.
//Note: Following line should be commented out when running Flutter Cookbook App on Web platform
void main() => runApp(CanvasPainting());

//StatefulWidget
class CanvasPainting extends StatefulWidget {
  @override
  _CanvasPaintingState createState() => _CanvasPaintingState();
}

class _CanvasPaintingState extends State<CanvasPainting> {
 ...
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      home: Scaffold(
        body: //Main canvas goes here,
        floatingActionButton: //FAB for the menu items goes here,
      ),
    );
  }
 ...
}

Detecting gestures:

We need a way to capture the user's tap. The GestureDetector widget is used to detect gestures. This widget is assigned to Scaffold widget's body property.

Since we want to paint on the given hut image. Feel free to use another image if you would like. However, don't forget to add this image to assets/images folder. Put this image in the center of the screen using Center widget. We want to draw on top of this image, so put this widget inside a Stack widget. Add CustomPaint as another child to this Stack widget.

CustomPaint widget takes two attributes. First, size of the canvas to be considered for drawing. Assign Size.infinite to size property because we want flexibility to be able draw anywhere on the screen.

Second, assign painter property to an instance of CustomPainter widget. We'll create a class MyPainter which extends CustomPainter. MyPainter class needs pointsList. This is the list of coordinates where screen is being touched. This information is required to draw either a line or a point on the screen.

//List of points touched at screen
List<TouchPoints> points = List();
  ...
body: GestureDetector(
  child: Stack(
    children: <Widget>[
      Center(
        child: Image.asset("assets/images/hut.png"),
      ),
      CustomPaint(
        size: Size.infinite,
        painter: MyPainter(
          pointsList: points,
        ),
      ),
    ],
  ),
),

The TouchPoints class:

This class holds the point information where screen is being touched.

//Class to define a point touched at canvas
class TouchPoints {
  Paint paint;
  Offset points;
  TouchPoints({this.points, this.paint});
}

MyPainter class:

The MyPainter class extends CustomPainter. It tells system how and when the screen will be painted. When two consecutive points are available, a line is detected otherwise a point is drawn.

class MyPainter extends CustomPainter {
  MyPainter({this.pointsList});

  //Keep track of the points tapped on the screen
  List<TouchPoints> pointsList;
  List<Offset> offsetPoints = List();

  //This is where we can draw on canvas.
  @override
  void paint(Canvas canvas, Size size) {
    for (int i = 0; i < pointsList.length - 1; i++) {
      if (pointsList[i] != null && pointsList[i + 1] != null) {

        //Drawing line when two consecutive points are available
        canvas.drawLine(pointsList[i].points, pointsList[i + 1].points,
            pointsList[i].paint);
      } else if (pointsList[i] != null && pointsList[i + 1] == null) {
        offsetPoints.clear();
        offsetPoints.add(pointsList[i].points);
        offsetPoints.add(Offset(
            pointsList[i].points.dx + 0.1, pointsList[i].points.dy + 0.1));

        //Draw points when two points are not next to each other
        canvas.drawPoints(PointMode.points, offsetPoints, pointsList[i].paint);
      }
    }
  }

  //Called when CustomPainter is rebuilt.
  //Returning true because we want canvas to be rebuilt to reflect new changes.
  @override
  bool shouldRepaint(MyPainter oldDelegate) => true;
}

At this point, our canvas is ready to process the touched points on the screen. However, we need to add detect and register this touched down points. For this purpose, we'll use GestureDetector widget's following properties:

The onPanStart property:

This property records the initial touched points. It requires paint property to provide information how touched points would be rendered on the screen. It extracts the position of touched points using RenderBox widget. A RenderBox is a render object in a 2D Cartesian coordinate system.

Here's description of this property from its class:

A pointer has contacted the screen with a primary button and has begun to move.

 onPanStart: (details) {
  setState(() {
    RenderBox renderBox = context.findRenderObject();
    points.add(TouchPoints(
        points: renderBox.globalToLocal(details.globalPosition),
        paint: Paint()
          ..strokeCap = strokeType
          ..isAntiAlias = true
          ..color = selectedColor.withOpacity(opacity)
          ..strokeWidth = strokeWidth));
  });
},

Let's define default properties for Paint() object as below:

 double opacity = 1.0;
 StrokeCap strokeType = StrokeCap.round;
 double strokeWidth = 3.0;
 Color selectedColor = Colors.black;

The onPanUpdate property:

This property is used to update the moving coordinates. For example, user is drawing a line without lifting off their finger.

Here's description of this property from its class:

A pointer that is in contact with the screen with a primary button and moving has moved again.

 onPanUpdate: (details) {
   setState(() {
     RenderBox renderBox = context.findRenderObject();
     points.add(TouchPoints(
         points: renderBox.globalToLocal(details.globalPosition),
         paint: Paint()
           ..strokeCap = strokeType
           ..isAntiAlias = true
           ..color = selectedColor.withOpacity(opacity)
           ..strokeWidth = strokeWidth));
   });
 },

The onPanEnd property:

This point describes the end of the screen contact with finger. So null is added to points list because there's no TouchPoints to be recorded.

Here's description of this property from its class:

A pointer that was previously in contact with the screen with a primary button and moving is no longer in contact with the screen and was moving at a specific velocity when it stopped contacting the screen.

 onPanEnd: (details) {
  setState(() {
    points.add(null);
  });
},

Action Items

There are following 7 action items that we want to add our toolkit.

Brush Stroke Picker
Opacity Picker
Resetting Screen
Red Color Picker
Green Color Picker
Pink Color Picker
Blue Color Picker

Add FAB menu

The FAB menu is implemented using AnimatedFloatingActionButton widget. This widget provides nice and smooth animation for menu open and close actions. It's assigned to Scaffold widget using floatingActionButton property.

`pubspec.yaml` Configuration

The AnimatedFloatingActionButton widget is provided by a Flutter plugin. Add plugin animated_floatactionbuttons: ^0.1.0 to pubspec.yaml

  animated_floatactionbuttons: ^0.1.0

Note: Don't forget to fetch the flutter packages after adding dependency.

Animating FAB

When FAB menu is clicked, it shows swift animation. We provide colors for starting and ending animation.

The Colors.blue is used as starting animation color. This can be assigned using colorStartAnimation property. The property colorEndAnimation is used to assign ending animation color, Colors.cyan.

When FAB menu open and closes, its icon(s) is changed using animatedIconData property.

This is how different colors can be assigned to AnimatedFloatingActionButton widget:

floatingActionButton: AnimatedFloatingActionButton(

  //Color shown when animation starts
  colorStartAnimation: Colors.blue,

  //Color shown when animation ends
  colorEndAnimation: Colors.cyan,

  //Icon for FAB. 'X' icon is shown when menu is open.
  animatedIconData: AnimatedIcons.menu_close,
),

Adding the buttons to FAB

The fabButtons property takes the buttons to be added to the AnimatedFloatingActionButton widget. We'll create fabOption() to return list of widgets to be shown as menu items.

Checkout the full code below:

//Optional app's entry point
void main() => runApp(CanvasPainting());

//StatefulWidget
class CanvasPainting extends StatefulWidget {
  @override
  _CanvasPaintingState createState() => _CanvasPaintingState();
}

class _CanvasPaintingState extends State<CanvasPainting> {
 ...
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      home: Scaffold(
        body: //Main canvas goes here,

        //FAB to implement expandable menu
        //needs plugin: `animated_floatactionbuttons`
        floatingActionButton: AnimatedFloatingActionButton(

          //Creating menu items
          fabButtons: fabOption(),

          //Color shown when animation starts
          colorStartAnimation: Colors.blue,

          //Color shown when animation ends
          colorEndAnimation: Colors.cyan,

          //Icon for FAB
          animatedIconData: AnimatedIcons.menu_close,
        ),
      ),
    );
  }
 ...
}

Let's checkout the fabOption() method next.

The `fabOption()` method

The method fabOption() returns the list of all menu items in the FAB menu. Assign this method to AnimatedFloatingActionButton widget using fabButtons property.

List<Widget> fabOption() {
  return <Widget>[

    //FAB for choosing stroke
    FloatingActionButton(
      heroTag: "paint_stroke",
      child: Icon(Icons.brush),
      tooltip: 'Stroke',
      onPressed: () {
        //min: 0, max: 50
        setState(() {
          _pickStroke();
        });
      },
    ),

    //FAB for choosing opacity
    FloatingActionButton(
      heroTag: "paint_opacity",
      child: Icon(Icons.opacity),
      tooltip: 'Opacity',
      onPressed: () {
        //min:0, max:1
        setState(() {
          _opacity();
        });
      },
    ),

    //FAB for resetting screen
    FloatingActionButton(
        heroTag: "erase",
        child: Icon(Icons.clear),
        tooltip: "Erase",
        onPressed: () {
          setState(() {
            points.clear();
          });
        }),

    //FAB for picking red color    
    FloatingActionButton(
      backgroundColor: Colors.white,
      heroTag: "color_red",
      child: colorMenuItem(Colors.red),
      tooltip: 'Color',
      onPressed: () {
        setState(() {
          selectedColor = Colors.red;
        });
      },
    ),

    //FAB for picking green color
    FloatingActionButton(
      backgroundColor: Colors.white,
      heroTag: "color_green",
      child: colorMenuItem(Colors.green),
      tooltip: 'Color',
      onPressed: () {
        setState(() {
          selectedColor = Colors.green;
        });
      },
    ),

    //FAB for picking pink color
    FloatingActionButton(
      backgroundColor: Colors.white,
      heroTag: "color_pink",
      child: colorMenuItem(Colors.pink),
      tooltip: 'Color',
      onPressed: () {
        setState(() {
          selectedColor = Colors.pink;
        });
      },
    ),

    //FAB for picking blue color
    FloatingActionButton(
      backgroundColor: Colors.white,
      heroTag: "color_blue",
      child: colorMenuItem(Colors.blue),
      tooltip: 'Color',
      onPressed: () {
        setState(() {
          selectedColor = Colors.blue;
        });
      },
    ),
  ];
}

Opacity Picker

The Opacity widget makes its child partially transparent. We want to support three values in our toolkit to pick from: 0.1, 0.5, and 1.0. The 0.1 is most transparent while 1.0 not at all. These options are shown in a alert dialog like below:

This is how your stroke look for opacity value of 0.1:

Implementing _opacity() method:

The _opacity() method implements selection of opacity as show in the screenshot.

We're providing three different values for opacity. The opacity = 1.0 is the maximum opacity. All options are displayed in AlertDialog widget. Selecting one option closes the dialog.

We'll use barrierDismissible to enable user to tap anywhere on the screen to close this dialog box.

ClipOval widget is used to create an oval shape clip of its child. You would notice slightly rounded corners for AlertDialog child.

Future<void> _opacity() async {
  //Shows AlertDialog
  return showDialog<void>(
    context: context,

    //Dismiss alert dialog when set true
    barrierDismissible: true,

    builder: (BuildContext context) {

      //Clips its child in a oval shape
      return ClipOval(
        child: AlertDialog(

          //Creates three buttons to pick opacity value.
          actions: <Widget>[
            FlatButton(
              child: Icon(
                Icons.opacity,
                size: 24,
              ),
              onPressed: () {
                //most transparent
                opacity = 0.1;
                Navigator.of(context).pop();
              },
            ),
            FlatButton(
              child: Icon(
                Icons.opacity,
                size: 40,
              ),
              onPressed: () {
                opacity = 0.5;
                Navigator.of(context).pop();
              },
            ),
            FlatButton(
              child: Icon(
                Icons.opacity,
                size: 60,
              ),
              onPressed: () {
                //not transparent at all.
                opacity = 1.0;
                Navigator.of(context).pop();
              },
            ),
          ],
        ),
      );
    },
  );
}

Brush Stroke Picker

The strokeWidth property sets the width of the stroke. .

These options are shown in the alert dialog like below. The 'X' is for resetting the stroke to its default value. The other three values are 10.0(thicker than default), 30.0, and 50.0 (thickest stroke).

The following screenshot shows all three options marked as 1, 2, and 3, where 1 is 10.0, 2 is 30.0, and 3 is 50.0.

Implementing _pickStroke() method:

The _pickStroke() method implements selection of the stroke.

We're providing four different width of strokes. All options are displayed in the AlertDialog widget. Selecting one option closes the dialog.

Future<void> _pickStroke() async {

  //Shows AlertDialog
  return showDialog<void>(
    context: context,

    //Dismiss alert dialog when set true
    barrierDismissible: true, // user must tap button!
    builder: (BuildContext context) {

      //Clips its child in a oval shape
      return ClipOval(
        child: AlertDialog(

          //Creates three buttons to pick stroke value.
          actions: <Widget>[

            //Resetting to default stroke value
            FlatButton(
              child: Icon(
                Icons.clear,
              ),
              onPressed: () {
                strokeWidth = 3.0;
                Navigator.of(context).pop();
              },
            ),
            FlatButton(
              child: Icon(
                Icons.brush,
                size: 24,
              ),
              onPressed: () {
                strokeWidth = 10.0;
                Navigator.of(context).pop();
              },
            ),
            FlatButton(
              child: Icon(
                Icons.brush,
                size: 40,
              ),
              onPressed: () {
                strokeWidth = 30.0;
                Navigator.of(context).pop();
              },
            ),
            FlatButton(
              child: Icon(
                Icons.brush,
                size: 60,
              ),
              onPressed: () {
                strokeWidth = 50.0;
                Navigator.of(context).pop();
              },
            ),
          ],
        ),
      );
    },
  );
}

Resetting Screen

Resetting screen clears all the recorded points:

points.clear();

Red, Green, Pink & Blue Color Picker(s)

The colorMenuItem(Color color) method provides the icon(s) for the given color(s). Tapping on that icon makes the color selection. ClipOval widget is used to give smooth round shape to colored icon.

Widget colorMenuItem(Color color) {
  return GestureDetector(
    onTap: () {
      setState(() {
        selectedColor = color;
      });
    },
    child: ClipOval(
      child: Container(
        padding: const EdgeInsets.only(bottom: 8.0),
        height: 36,
        width: 36,
        color: color,
      ),
    ),
  );
}

The above colorMenuItem(...) method is used to create oval menu items for all the four colors.

That's all for this article. Hope you've your own finger painting app on your finger tips :)

NOTE: This code has been developed in following dev environment:

Flutter 1.15.17 • channel beta • https://github.com/flutter/flutter.git
Framework • revision 2294d75bfa (4 weeks ago) • 2020-03-07 00:28:38 +0900
Engine • revision 5aff311948
Tools • Dart 2.8.0 (build 2.8.0-dev.12.0 9983424a3c)

Source code repo

Recipe source code is available here
Code recipe project's source code is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Follow me at twitter

Adding Syntax Highlighting in Flutter Cookbook App

2020-02-06T00:00:00-05:00

Target Audience: Beginner

Recipe: Displaying code snippets for Flutter Cookbook code recipes.

Focus Widget: syntax_highlighter plugin

Checkout the companion video tutorial:

Lets's go!

`pubspec.yaml` dependency

Add syntax_highlighter plugin dependency as below:

dependencies:
  flutter:
    sdk: flutter

  #Highlighting syntax in code snippets for code recipes
  syntax_highlighter: ^0.1.0

  #To provide Floating Action widget to zoom in and out code snippet text
  animated_floatactionbuttons: ^0.1.0

syntax_highlighter plugin: This plugin is used to highlight syntax in code snippets for code recipes.
animated_floatactionbuttons plugin: This plugin is used to provide Floating Action widget to zoom in and out code snippet text.

CodeFileWidget: A `StatefulWidget` to display Code snippet

Class CodeFileWidget is a StatefulWidget. It's responsible to display underlying code for a Flutter code recipe.

This class takes four parameters to populate appropriate code snippet in CodeFileWidget.

recipeName: Code recipe's name to display in the appBar at the top.
pageName: This is used to routing purposes. In this particular app, this is a required parameter to navigate the recipe's code and its preview and vice versa.
codeFilePath: This is the location of code file in the code. For example: lib/pdf/. Don't forget to add this path in assets section of pubspec.yaml file like below:

assets:
  - lib/pdf/

codeGithubPath: This is the external https:// link to code's file in Github repo.

class CodeFileWidget extends StatefulWidget {
  final String recipeName;
  final String pageName;
  final String codeFilePath;
  final String codeGithubPath;

  CodeFileWidget(
      {this.recipeName, this.pageName, this.codeFilePath, this.codeGithubPath});

  @override
  CodeFileWidgetState createState() {
    return CodeFileState();
  }
}


class CodeFileWidgetState extends State<CodeFileWidget> {
  double scaleFactorText = 1.0;

  @override
  Widget build(BuildContext context) {
    ...
    );
  }

  List<Widget> codepreviewActions(String codeContent) {
    ...
  }

  Widget highlightCodeSyntax(String codeContent, BuildContext context) {
    ...
  }
}

Next, we'll go over the each of the three methods of CodeFileWidgetState. Please note that default scale factor value for text is set to 1: double scaleFactorText = 1.0;

Building screen

First, we'll build the main interface to display code snippet.

AppBar: The App Bar has an action to open the external link to Github repository file. Title displays the recipe name.

FutureBuilder: FutureBuilder loads the file contents of the passed codeFilePath file. It shows the CircularProgressIndicator widget while file contents are loading. Once the data is available, highlightCodeSyntax(...) method takes the file contents and highlights syntax.

AnimatedFloatingActionButton : AnimatedFloatingActionButton is used to show actions to zoom_in and zoom_out code, and to navigate to the demo view.

@override
Widget build(BuildContext context) {
  return Scaffold(
    appBar: AppBar(
      leading: IconButton(
        icon: Icon(Icons.arrow_back),
        onPressed: () => Navigator.pop(context),
      ),
      title: Text(widget.recipeName),
      actions: <Widget>[
        IconButton(
          icon: Icon(Icons.open_in_new),
          onPressed: () => UrlUtils.open(this.widget.codeGithubPath),
        )
      ],
    ),
    body: FutureBuilder(
      future: rootBundle.loadString(widget.codeFilePath) ??
          'Error loading code file ${this.widget.codeFilePath}',
      builder: (BuildContext context, AsyncSnapshot<String> snapshot) {
        if (snapshot.hasData) {
          return Scaffold(
            body: Padding(
              padding: EdgeInsets.all(4.0),
              child: highlightCodeSyntax(snapshot.data, context),
            ),
            floatingActionButton: AnimatedFloatingActionButton(
              fabButtons: codepreviewActions(),
              colorStartAnimation: Colors.blue,
              colorEndAnimation: Colors.cyan,
              animatedIconData: AnimatedIcons.menu_close,
            ),
          );
        } else {
          return Center(child: CircularProgressIndicator());
        }
      },
    ),
  );
}

Adding actions

Now, add actions like zoom_in, zoom_out, and navigating to code recipe demonstration.

Zooming Out: scaleFactorText's value is decreased by 0.1 every time 'Zoom out' widget is tapped. That means text is made smaller.
Zooming In: scaleFactorText's value is increased by 0.1 every time 'Zoom out' widget is tapped. That means text is made bigger. You can see more text at a time.
Navigating to Code demo: Tapping on this action opens the code recipe demonstration screen.

List<Widget> codepreviewActions() {
  return <Widget>[
  //making text smaller
    FloatingActionButton(
      heroTag: "zoom_out",
      child: Icon(Icons.zoom_out),
      tooltip: 'Zoom out',
      onPressed: () => setState(() {
        this.scaleFactorText = max(0.8, this.scaleFactorText - 0.1);
      }),
    ),
    //making text bigger
    FloatingActionButton(
      heroTag: "zoom_in",
      child: Icon(Icons.zoom_in),
      tooltip: 'Zoom in',
      onPressed: () => setState(() {
        this.scaleFactorText += 0.1;
      }),
    ),
    FloatingActionButton(
      heroTag: "open_page",
      child: Icon(Icons.slideshow),
      tooltip: 'See Demo',
      onPressed: () => Navigator.popAndPushNamed(
        context,
        widget.pageName,
        arguments: ScreenArguments(widget.recipeName, widget.pageName,
            widget.codeFilePath, widget.codeGithubPath),
      ),
    ),
  ];
}

Highlighting code syntax

This is the main method which is responsible to highlight syntax for the code file. Plugin provides SyntaxHighlighterStyle class to help provide the correct theme for the current platform's theme (light vs dark).

Container widget is used to display the code snippet using BoxConstraints.expand() constraints.

Scrollbar widget uses two nested SingleChildScrollView widgets. First one provides the vertical scrolling by default. Second SingleChildScrollView sets its scrollDirection property to Axis.horizontal to provide horizontal scrolling.

RichText widget uses textScaleFactor property to adapt the variable value for scaleFactorText.

TextSpan widget uses monospace fontFamily to show code in a readable view.

Plugin's DartSyntaxHighlighter class uses the chosen SyntaxHighlighterStyle to render file content using proper syntax highlighting.

Widget highlightCodeSyntax(String codeContent, BuildContext context) {
  final SyntaxHighlighterStyle style =
      Theme.of(context).brightness == Brightness.dark
          ? SyntaxHighlighterStyle.darkThemeStyle()
          : SyntaxHighlighterStyle.lightThemeStyle();
  return Container(
    constraints: BoxConstraints.expand(),
    child: Scrollbar(
      child: SingleChildScrollView(
        child: SingleChildScrollView(
          scrollDirection: Axis.horizontal,
          child: RichText(
            textScaleFactor: this.scaleFactorText,
            text: TextSpan(
              style: TextStyle(fontFamily: 'monospace', fontSize: 12.0),
              children: <TextSpan>[
                DartSyntaxHighlighter(style).format(codeContent)
              ],
            ),
          ),
        ),
      ),
    ),
  );
}

Source code repo

Recipe source code for CodeFileWidget class is available here
Flutter Cookbook project's source code is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Follow me at twitter

Loading PDF file from Firebase Storage in Flutter App (Android, iOS & Web)

2020-02-03T00:00:00-05:00

Target Audience: Beginner

Recipe: Loading PDF file from Firebase Storage in Flutter Native & WebApp.

Goal: In this code recipe, we'll do following:

Review Firebase Project and configuration setup.
Checkout availability of PDF file in FirebaseStorage using Firebase Console.
Fetching PDF from Firebase Storage.
Checkout code for loading pdf in native and web app environments.

Note: Please review this article about Firebase Login, if you run into permissions issues accessing PDF. Android platform expects user to be logged in.

Flutter Cookbook:

Android:

iOS:

Flutter Web:

Checkout the Youtube video:

Introduction

This code recipe would demonstrate loading PDF file from Firebase Storage in Flutter Native and Web Apps. I'm using my Flutter talks's slides as PDF file. I've this PDF available in Firebase Storage already.

Firebase Project review

Project Setup:

Make sure that your Firebase project is configured for all three platforms.

Android: Checkout this link to configure Firebase project for Android app.
iOS: Checkout this link to configure Firebase project for iOS app.
Web: Checkout this link to configure Firebase project for Flutter Web app.

Images in Firebase Storage Console:

I've uploaded Flutter presentation's slides as PDF in Firebase Storage as shown in screenshot below.

Don't forget to tune Firebase Storage files 'Rules' depending on your usage. For demonstration purposes for this code recipe, I want to let user read images regardless of their authentication status. So, I'm making pdf bucket readable to all as shown in screenshot below:

`pubspec.yaml` dependencies

Flutter plugins for accessing files from FirebaseStorage for Native apps are similar to previous article about Loading images from Firebase Storage

dependencies:

  #http to download PDF
  http: ^0.12.0+4
  #Open PDF in a viewer
  flutter_full_pdf_viewer: ^1.0.6

  #Firebase related
  firebase_storage: ^3.0.8
  firebase_core: ^0.4.0+9
  firebase_analytics: ^5.0.6

Flutter plugin for accessing files in Firebase Storage for Web apps:

dependencies:
  firebase: ^5.0.4

Code Structure for loading PDF

I want to fetch PDF from firebase as the first thing. For this purpose I'll be fetching it in initState() method. file variable holds the path of the pdf file in FirebaseStorage. fileName variable is used to display the name for the PDF in app bar. First, LaunchFile.loadFromFirebase(context, file) method fetches the PDF file from FirebaseStorage, and then it is passed to LaunchFile.createFileFromPdfUrl(url) to take appropriate action on the targeted platform. For Native platform, remote pdf is downloaded on the disk and named as flutterSlides.pdf. On Web platform, PDF file's url is opened in another tab.

String file = "pdfs/slides.pdf";
String fileName = "Flutter Slides";

class LoadFirbaseStoragePdf extends StatefulWidget {
  @override
  _LoadFirbaseStoragePdfState createState() => _LoadFirbaseStoragePdfState();
}

class _LoadFirbaseStoragePdfState extends State<LoadFirbaseStoragePdf> {
  static String pathPDF = "";
  static String pdfUrl = "";

  @override
  void initState() {
    super.initState();

    //Fetch file from FirebaseStorage first
    LaunchFile.loadFromFirebase(context, file)
        //Creating PDF file at disk for ios and android & assigning pdfUrl for web
        .then((url) => LaunchFile.createFileFromPdfUrl(url).then(
              (f) => setState(
                () {
                  if (f is File) {
                    pathPDF = f.path;
                  } else if (url is Uri) {
                    //Open PDF in tab (Web)
                    pdfUrl = url.toString();
                  }
                },
              ),
            ));
  }
  ...
}

Once the app has information about the PDF file, 'Open PDF' button will open it another screen:

FlatButton(
          onPressed: () {
            setState(() {
              LaunchFile.launchPDF(
                  context, "Flutter Slides", pathPDF, pdfUrl);
            });
          },
          child: Text(
            "Open PDF",
            style: TextStyle(fontSize: 20),
          ),
        )

File launch_pdf.dart uses dart.library to decide on redirecting calls to native vs web implementation for LaunchFile.

export 'unsupported_pdf.dart'
    if (dart.library.html) 'web_pdf.dart'
    if (dart.library.io) 'mobile_pdf.dart';

web_pdf.dart has web related implementations while mobile_pdf.dart file addresses native platforms (Android & iOS). Anything else goes to unsupported_pdf.dart.

Let's checkout each of these files below:

`unsupported_pdf.dart`

For every platform that's not supported by our application will throw appropriate exceptions.

import 'package:flutter/material.dart';

class LaunchFile {
  static void launchPDF(
      BuildContext context, String title, String pdfPath, String pdfUrl) {
    throw ("Platform not found");
  }

  static Future<dynamic> loadFromFirebase(BuildContext context, String url) {
    throw ("Platform not found");
  }

  static Future<dynamic> createFileFromPdfUrl(dynamic url) async {
    throw ("Platform not found");
  }
}

Loading Image in Flutter Web App (`web_pdf.dart`)

Web platform uses following implementation for the LaunchFile class:

import 'package:flutter/material.dart';
import 'package:flutter_widgets/plugins/firetop/storage/fire_storage_service.dart';
import 'package:flutter_widgets/plugins/url_launcher/url_launcher.dart';

class LaunchFile {
  static void launchPDF(
      BuildContext context, String title, String pdfPath, String pdfUrl) async {
    UrlUtils.open(pdfUrl);
  }

  static Future<dynamic> loadFromFirebase(
      BuildContext context, String url) async {
    return FireStorageService.loadFromStorage(context, url);
  }

  static Future<dynamic> createFileFromPdfUrl(dynamic url) async {
    return url;
  }
}

launchPDF(...): url_launcher plugin will open the PDF in browser tab for Flutter Web. It uses pdfUrl parameter.
loadFromFirebase(...): Checkout firetop plugin directory to familiarize yourself with the platform specific call re-direction for accessing FirebaseStorage.
createFileFromPdfUrl(...): This method simply return the url for the PDF to help open the file in browser's tab.

Loading PDF file in Flutter Native App (`mobile_pdf.dart`)

import 'dart:io';

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:flutter_widgets/pdf/load_pdf.dart';
import 'package:flutter_widgets/pdf/pdf_screen.dart';
import 'package:path_provider/path_provider.dart';
import 'package:flutter_widgets/plugins/firetop/storage/fire_storage_service.dart';

class LaunchFile {
  static void launchPDF(
      BuildContext context, String title, String pdfPath, String pdfUrl) {
    Navigator.push(
      context,
      MaterialPageRoute(
        builder: (context) => PDFScreen(title, pdfPath, pdfUrl),
      ),
    );
  }

  static Future<dynamic> loadFromFirebase(
      BuildContext context, String url) async {
    return FireStorageService.loadFromStorage(context, file);
  }

  static Future<dynamic> createFileFromPdfUrl(dynamic url) async {
    final filename =
        'flutterSlides.pdf'; //I did it on purpose to avoid strange naming conflicts
    print(filename);
    var request = await HttpClient().getUrl(Uri.parse(url));
    var response = await request.close();
    var bytes = await consolidateHttpClientResponseBytes(response);
    String dir = (await getApplicationDocumentsDirectory()).path;
    File file = new File('$dir/$filename');
    await file.writeAsBytes(bytes);
    return file;
  }
}

launchPDF(...): On native platform, this method opens the PDF file in a Flutter screen as below:

import 'package:flutter/material.dart';
import 'package:flutter_full_pdf_viewer/flutter_full_pdf_viewer.dart';
import 'package:flutter_full_pdf_viewer/full_pdf_viewer_scaffold.dart';

class PDFScreen extends StatelessWidget {
  String title = "";
  String pdfPath;
  String pdfUrl;
  PDFScreen(this.title, this.pdfPath, this.pdfUrl);

  @override
  Widget build(BuildContext context) {
    return PDFViewerScaffold(
        appBar: AppBar(
          backgroundColor: Colors.blue,
          title: Text(title),
          actions: <Widget>[
            IconButton(
              icon: Icon(Icons.share),
              onPressed: () {},
            ),
          ],
        ),
        path: pdfPath);
  }
}

loadFromFirebase(...): Checkout firetop plugin directory to familiarize yourself with the platform specific call re-direction for accessing FirebaseStorage.
createFileFromPdfUrl(...): This method downloads the pdf file from FirebaseStorage to a local file at disk. This local pdf file is later opened in PDFScreen later.

That's all you need to load a PDF file from FirebaseStorage into your Flutter application.

Note: Checkout my previous article about plugins directory structure in details, and supporting web and native app's from single source code.

Source code repo

Recipe source code is available here
Flutter Cookbook project's source code is available here

References:

Related article about loading image from FirebaseStorage about supporting web and native app's from single source code.
Configure Firebase project for Flutter Native Android app.
Configure Firebase project for Flutter Native iOS app.
Configuring Firebase project for Flutter Web app.

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Follow me at twitter

Persisting theme in LocalDatabase (Moor plugin)

2019-12-31T00:00:00-05:00

Background

In this previous article, we saw how to implement theme switching using Provider. In this article, we'll see how to save the selected theme in app's local database to persist the last selected theme across app restarts.

Checkout related articles:

Target Audience: Beginner

Recipe: Persist selected theme in FlutterApp's local database using Moor plugin.

Focus Widget: Moor plugin

Goal: Persisting chosen theme in local database. Implement a simple UI with an image, text and a button to switch themes. Page's default theme is light. Clicking on "Switch Theme" button will apply dark theme to page, and vice versa. Switching theme will save selected theme in app's local database using Moor plugin.

Light Theme:

Dark Theme:

Checkout the companion video tutorial:

Note: In this article, I'll only focus on persisting data in database. Please refer to previous article for app architecture and other details.

Step #1. `pubspec.yaml`

Add package dependencies in pubspec.yaml:

dependencies:
  flutter:
    sdk: flutter

  moor: ^2.2.0

  # Dart bindings to sqlite
  moor_ffi: ^0.2.0

  # Helper to find the database path on mobile
  path_provider: ^1.5.1
  path: ^1.6.4

  dev_dependencies:
    flutter_test:
      sdk: flutter

    #This generator library turns Table classes from moor into database code.
    moor_generator: ^2.2.0

    #generates files using Dart code.  
    build_runner: ^1.4.0

moor plugin : Persistence library built on top of sqlite for Dart and Flutter. It works on Android, iOS and Web platforms for persisting data in local databases.
moor_ffi plugin : This Flutter plugin generates Dart bindings to sqlite by using dart:ffi. ffi stands for Foreign Function Interface. This plugin can be used with Flutter and/or Dart VM applications and supports all platforms where sqlite3 is installed: iOS, Android (Flutter), macOS, Linux and Windows. NOTE: This plugin is being phased out, and recommended to migrate to newer implementation.
path_provider plugin : This Flutter plugin is used for accessing filesystem on Android and iOS platforms.
path plugin : A cross-platform filesystem path manipulation library for Dart.
moor_generator plugin : This library contains the generator that turns your Table classes from moor into database code.
build_runner plugin : This package is used to generate files. We need this package to be able to run this command flutter packages pub run build_runner build --delete-conflicting-outputs to generate *.g.dart files.

Step #2. Using Moor to prepare Database

First, we'll use Moor to prepare Database to save theme_id and theme_name. Selected theme's id will be saved. This table will have only one entry at a given time. When theme switched from light to dark, the older entry will be deleted, and newly selected theme's id will be added to this table. I kept it simple on purpose to demonstrate how moor can be integrated in your app.

Let's take look at our database file : themes_pref.dart below.

import 'package:flutter_widgets/themes/db/themes_notifier_db.dart';
import 'package:moor/moor.dart';

part 'theme_prefs.g.dart';

// this will generate a table called "theme_prefs" for us. The rows of that table will
// be represented by a class called "ThemePref".
class ThemePrefs extends Table {
  // MyThemes id
  IntColumn get theme_id => integer()();
  TextColumn get theme_name => text()();
}

// Moor prepares database table
@UseMoor(tables: [ThemePrefs])
class MyDatabase extends _$MyDatabase {
  MyDatabase(QueryExecutor e) : super(e);

  // Bump schemaVersion whenever there's change.
  @override
  int get schemaVersion => 1;

  //Keeping it simple
  //reset the database whenever there's update.
  // Add light theme as default theme after first launch and upgrade
  @override
  MigrationStrategy get migration {
    return MigrationStrategy(onCreate: (Migrator m) {
      return m.createAllTables();
    }, onUpgrade: (Migrator m, int from, int to) async {
      m.deleteTable(themePrefs.actualTableName);
      m.createAllTables();
    }, beforeOpen: (details) async {
      if (details.wasCreated) {
        await into(themePrefs).insert(ThemePrefsCompanion(
          theme_id: const Value(0),
          theme_name: Value(MyThemes.light.toString()),
        ));
      }
    });
  }

  void activateTheme(MyThemes theme) {
    ThemePref pref =
        ThemePref(theme_id: theme.index, theme_name: theme.toString());
    into(themePrefs).insert(pref);
  }

  void deactivateTheme(int i) =>
      (delete(themePrefs)..where((t) => t.theme_id.equals(i))).go();

  //The stream will automatically emit new items whenever the underlying data changes.
  Stream<bool> themeIdExists(int id) {
    return select(themePrefs)
        .watch()
        .map((prefs) => prefs.any((pref) => pref.theme_id == id));
  }

  Future<ThemePref> getActiveTheme() {
    return select(themePrefs).getSingle();
  }
}

Please note that this line will show error in the beginning because this file doesn't exist yet: part 'theme_prefs.g.dart';. You'll need to execute following command to generate sqlite bindings:

  flutter packages pub run build_runner build --delete-conflicting-outputs

ThemePrefs table contains only two fields: theme_id to save id for the theme and another field for saving name.

class ThemePrefs extends Table {
  // MyThemes id
  IntColumn get theme_id => integer()();
  TextColumn get theme_name => text()();
}

Following part actually prepares database table. This is the class where migration strategy is described. I kept migration strategy simple in this recipe. It resets the tables, and make light theme default in case of first launch or upgrade.

@UseMoor(tables: [ThemePrefs])
class MyDatabase extends _$MyDatabase {

}

Step #3. Sharing Database implementation across platforms

We'll be creating one file to write shared code, and two files for native and web implementation for accessing database on corresponding platforms.

Shared: shared.dart

export 'unsupported.dart'
    if (dart.library.html) 'web.dart'
    if (dart.library.io) 'mobile.dart';

Native (Android / iOS): mobile.dart

//Note: Implementation borrowed from this To Do App Template project
//https://github.com/appleeducate/moor_shared
MyDatabase constructDb({bool logStatements = false}) {
  if (Platform.isIOS || Platform.isAndroid) {
    final executor = LazyDatabase(() async {
      final dataDir = await paths.getApplicationDocumentsDirectory();
      final dbFile = File(p.join(dataDir.path, 'db.sqlite'));
      return VmDatabase(dbFile, logStatements: logStatements);
    });
    return MyDatabase(executor);
  }
  if (Platform.isMacOS || Platform.isLinux) {
    final file = File('db.sqlite');
    return MyDatabase(VmDatabase(file, logStatements: logStatements));
  }
  if (Platform.isWindows) {
    final file = File('db.sqlite');
    return MyDatabase(VmDatabase(file, logStatements: logStatements));
  }
  return MyDatabase(VmDatabase.memory(logStatements: logStatements));
}

Web: web.dart

MyDatabase constructDb({bool logStatements = false}) {
  return MyDatabase(WebDatabase('db', logStatements: logStatements));
}

Checkout this link to configure Moor for FlutterWeb.

Unsupported platform: unsupported.dart

MyDatabase constructDb({bool logStatements = false}) {
  throw 'Platform not supported';
}

Checkout db plugin source code here.

Step #4. App's entry point

This code recipe is a part of the code recipes app as shown below:

There are two ways to run this code recipe:

StandAlone: Use following code snippet at the top of the themes_db.dart to run it independently.

void main() => runApp(MultiProvider(
      providers: [
        Provider<MyDatabase>(
          builder: (_) => constructDb(logStatements: true),
          dispose: (context, db) => db.close(),
        ),
        ChangeNotifierProvider<ThemesNotifierDB>(
          builder: (_) {
            return ThemesNotifierDB();
          },
        )
      ],
      child: ThemesDBCaching(),
    ));

Code Recipe App: Use following code in router.dart to run this code recipe as part of the code recipe app.

case THEMES_DEMO_DB:
  return MaterialPageRoute(builder: (context) {
    return MultiProvider(
      providers: [
        Provider<MyDatabase>(
          builder: (_) => constructDb(logStatements: true),
          dispose: (context, db) => db.close(),
        ),
        ChangeNotifierProvider<ThemesNotifierDB>(
          builder: (_) {
            return ThemesNotifierDB();
          },
        )
      ],
      child: ThemesDBCaching(),
    );
  });
  break;

Step #5. Loading theme from database

Stateful widget ThemesDBCaching loads active theme using Provider.of<ThemesNotifierDB>(context).loadActiveThemeData(context);

themes_db.dart:

Here's code snippet:

class _ThemesDBCachingState extends State<ThemesDBCaching> {
  @override
  Widget build(BuildContext context) {

    Provider.of<ThemesNotifierDB>(context).loadActiveThemeData(context);

    return MaterialApp(
        theme: Provider.of<ThemesNotifierDB>(context).currentThemeData,
        home: Scaffold(
          appBar: AppBar(
            title: Text("Theme DB Caching (Moor)"),
          ),
          body: body(),
        ));
  }
  ...
}

themes_notifier_db.dart:

Fetching theme_id from database, loading and notifying currentTheme:

//fetch theme_id from database
Future<int> getActiveThemeID(BuildContext context) {
  return Provider.of<MyDatabase>(context)
      .getActiveTheme()
      .then((themePref) => themePref.theme_id);
}

//Load active theme using theme_id
void loadActiveThemeData(BuildContext context) async {
  int themeId = await getActiveThemeID(context);
  currentTheme = MyThemes.values[themeId];
}

//notify to listeners about the updated theme
set currentTheme(MyThemes theme) {
  if (theme != null) {
    _currentTheme = theme;
    _currentThemeData = themeData[_currentTheme.index];
    notifyListeners();
  }
}

Step #6: Switching and Saving theme to database

Switching theme toggles previously selected theme. oldTheme is removed from the database using deactivateTheme(...). Newly updated currentTheme is added to database using activateTheme(...).

void switchTheme(BuildContext context) async {
  var oldTheme = currentTheme;

  currentTheme == MyThemes.light
      ? currentTheme = MyThemes.dark
      : currentTheme = MyThemes.light;

  var myDatabase = Provider.of<MyDatabase>(context);
  var isOldThemeActive = myDatabase.themeIdExists(oldTheme.index);

  if (isOldThemeActive != null) {
    myDatabase.deactivateTheme(oldTheme.index);
  }

  myDatabase.activateTheme(currentTheme);
}

All Done !

Source Code

Recipe source code is available here
Code recipe project's source code is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Follow me at twitter

Persisting theme using SharedPreferences (Android, iOS, and Web)

2019-12-30T00:00:00-05:00

Background

In this previous article, we saw how to implement theme switching using Provider. In this article, we'll see how to persist the selected theme using SharedPreferences Flutter plugin. iOS platform uses NSUserDefaults and Android platform uses SharedPreferences implementations to store simple data to disk asynchronously.

The difference between persisting data using SharedPreferences plugin vs local database is that SharedPreferences plugin can not guarantee that writes will be persisted to disk after app restarts. However, saving data to local database is more reliable.

Checkout related articles:

Target Audience: Beginner

Recipe: Persisting selected theme using SharedPreferences plugin.

Focus Widget: SharedPreferences plugin

Goal: Persisting chosen theme in disk. Implement a simple UI with an image, text and a button to switch themes. Page's default theme is light. Clicking on "Switch Theme" button will apply dark theme to page, and vice versa. Switching theme will save selected theme using SharedPreferences plugin for Android, iOS and FlutterWeb. Flutter Web is supported since version: 0.5.6.

Light Theme:

Dark Theme:

Checkout the companion video tutorial:

Note: In this article, I'll only focus on persisting data using SharedPreferences plugin. Please refer to previous article for app architecture and other details.

Step #1. `pubspec.yaml`

Add package dependencies in pubspec.yaml:

dependencies:
  flutter:
    sdk: flutter

  #SharedPreferences plugin for Android, iOS and Web
  shared_preferences: ^0.5.6

Step #2. App's entry point

This code recipe is a part of the code recipes app as shown below:

There are two ways to run this code recipe:

StandAlone: Use following code snippet at the top of the themes_db.dart to run it independently.

void main() => runApp(ChangeNotifierProvider<ThemesNotifierSharedPrefs>(
    child: ThemesSharedPrefsCaching(),
    builder: (BuildContext context) {
      return ThemesNotifierSharedPrefs();
    }));

Code Recipe App: Use following code in router.dart to run this code recipe as part of the code recipe app.

case THEMES_DEMO_SHAREDPREFS:
  return MaterialPageRoute(builder: (context) {
    return ChangeNotifierProvider<ThemesNotifierSharedPrefs>(
      child: ThemesSharedPrefsCaching(),
      builder: (BuildContext context) {
        return ThemesNotifierSharedPrefs();
      },
    );
  });
  break;

Step #3. Loading theme from SharedPreferences

Stateful widget ThemesSharedPrefsCaching loads active theme using Provider.of<ThemesNotifierSharedPrefs>(context) .loadActiveThemeData(context);

themes_sharedPrefs.dart:

class _ThemesSharedPrefsCachingState extends State<ThemesSharedPrefsCaching> {
  @override
  Widget build(BuildContext context) {
    Provider.of<ThemesNotifierSharedPrefs>(context)
        .loadActiveThemeData(context);
    return MaterialApp(
        theme: Provider.of<ThemesNotifierSharedPrefs>(context).currentThemeData,
        home: Scaffold(
          appBar: AppBar(
            title: Text("Theme Caching (SharedPreference)"),
          ),
          body: body(),
        ));
  }
  ...
}

themes_notifier_sp.dart:

Fetching theme_id from database, loading and notifying currentTheme:

class ThemesNotifierSharedPrefs with ChangeNotifier {

  ...

  Future<void> activateTheme(MyThemes theme) async {
    var sharedPrefs = await SharedPreferences.getInstance();
    await sharedPrefs.setInt('theme_id', theme.index);
  }

  void loadActiveThemeData(BuildContext context) async {
    var sharedPrefs = await SharedPreferences.getInstance();
    int themeId = sharedPrefs.getInt('theme_id') ?? MyThemes.light.index;
    currentTheme = MyThemes.values[themeId];
  }

  set currentTheme(MyThemes theme) {
    if (theme != null) {
      _currentTheme = theme;
      _currentThemeData = themeData[_currentTheme.index];
      notifyListeners();
    }
  }

}

Step #4. Switching and Saving theme to database

Switching theme toggles previously selected theme. We don't need to explicitly remove old theme since sharedPrefs key theme_id is updated to new value. Newly updated currentTheme overwrites the theme_id using api activateTheme(...).

class ThemesNotifierSharedPrefs with ChangeNotifier {

  ...

  void switchTheme(BuildContext context) async {
    currentTheme == MyThemes.light
        ? currentTheme = MyThemes.dark
        : currentTheme = MyThemes.light;

    activateTheme(currentTheme);
  }

  ...
}

All Done !

Source Code

Recipe source code is available here
Code recipe project's source code is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Follow me at twitter

Text-to-Speech Flutter Plugin (Android & iOS)

2019-12-02T00:00:00-05:00

Target Audience: Beginner

Recipe: Using text-to-speech Flutter plugin to read aloud text.

Focus Plugin: Text-To-Speech Flutter plugin: flutter_tts

Goal: We've a card with an image and its description. Clicking on play button will start reading aloud card's description, and stops when done.

Note: This recipe has been added to Flutter cookbook code recipe app as shows below.

Android:

iOS:

Checkout the Youtube video:

Lets's go!

This code recipe demonstrate implementation for Text-to-speech Flutter plugin

`pubspec.yaml` dependencies

Add dependency for flutter_tts plugin:

dependencies:
  flutter_tts: ^0.7.0

StatefulWidget

We need StatefulWidget as parent widget since we'll be triggering speaking on the touch of the play button.

description is the text to be read on the click on play button.
isPlaying is the flag to keep track whether text is being read or not. We need this flag to show appropriate Icon (play or stop) in the card.
FlutterTts _flutterTts is the instance of flutter_tts plugin. It's a wrapper around the native implementation for Android and iOS to interact with native functionality. Under the hood, it uses TextToSpeech for Android, and AVSpeechSynthesizer for iOS platform.

class TTSPluginRecipe extends StatefulWidget {
  @override
  _TTSPluginRecipeState createState() => _TTSPluginRecipeState();
}

class _TTSPluginRecipeState extends State<TTSPluginRecipe> {
  String description =
      "The Griffith Observatory is the most iconic building in Los Angeles, perched high in the Hollywood Hills, 1,134 feet above sea level.";

  bool isPlaying = false;
  FlutterTts _flutterTts;    
}

Plugin management: Initializing & Disposing

Initializing plugin for Android is slightly different than for iOS. We need to detect the platform to run the specific code. Please checkout PlatformUtil to understand how I'm detecting platforms.

@override
void initState() {
  super.initState();
  initializeTts();
}

initializeTts() {
  _flutterTts = FlutterTts();

  if (PlatformUtil.myPlatform() == MyPlatform.ANDROID) {
    _flutterTts.ttsInitHandler(() {
      setTtsLanguage();
    });
  } else if (PlatformUtil.myPlatform() == MyPlatform.IOS) {
    setTtsLanguage();
  } else if (PlatformUtil.myPlatform() == MyPlatform.WEB) {
    //not-supported by plugin
  }

  _flutterTts.setStartHandler(() {
    setState(() {
      isPlaying = true;
    });
  });

  _flutterTts.setCompletionHandler(() {
    setState(() {
      isPlaying = false;
    });
  });

  _flutterTts.setErrorHandler((err) {
    setState(() {
      print("error occurred: " + err);
      isPlaying = false;
    });
  });
}


@override
void dispose() {
  super.dispose();
  _flutterTts.stop();
}

Don't forget to stop flutter_tts plugin instance in dispose() method.

Speaking & Stopping

Speaking and Stop speaking is pretty straight forward. All you need to call plugin's speak(String text) and stop() methods / apis.

Future _speak(String text) async {
  if (text != null && text.isNotEmpty) {
    var result = await _flutterTts.speak(text);
    if (result == 1)
      setState(() {
        isPlaying = true;
      });
  }
}

Future _stop() async {
  var result = await _flutterTts.stop();
  if (result == 1)
    setState(() {
      isPlaying = false;
    });
}

Exploring plugin's features

Setting Language:

void setTtsLanguage() async {
  await _flutterTts.setLanguage("en-US");
}

Getting list of supported languages:

  await flutterTts.getLanguages`

Setting Voice:

_flutterTts.setVoice("en-us-x-sfg#male_1-local")

Getting list of supported voices:

  await flutterTts.getVoices

Source code repo

Recipe source code is available here
Code recipe project's source code is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Follow me at twitter

Loading image from Firebase Storage in Flutter App (Android, iOS & Web)

2019-11-22T00:00:00-05:00

Target Audience: Beginner

Recipe: Implement loading image from Firebase Storage on Flutter Native and Flutter WebApp.

Goal: In this code recipe, we'll do following:

Touch basing Firebase Project and configuration setup.
Touch basing availability of the two sample images in Storage using Firebase Console.
Fetching one of the image randomly from Firebase Storage.
Checkout code for loading image in native and web app.

Android:

iOS:

Flutter Web:

Checkout the Youtube video:

Lets's go!

This code recipe would demonstrate image Loading from Firebase Storage in Flutter Native and Web Apps.

Step #1. `pubspec.yaml` dependencies

Flutter plugin for accessing images in FirebaseStorage for Native apps:

dependencies:
  firebase_storage: ^3.0.8
  firebase_core: ^0.4.0+9
  firebase_analytics: ^5.0.6

Flutter plugin for accessing files in Firebase Storage for Web apps:

dependencies:
  firebase: ^5.0.4

Step #2. Firebase Project review

Project Setup:

Make sure that your Firebase project is configured for all three platforms.

Android: Checkout this link to configure Firebase project for Android app.
iOS: Checkout this link to configure Firebase project for iOS app.
Web: Checkout this link to configure Firebase project for Flutter Web app.

Images in Firebase Storage Console:

I've uploaded two images in Storage as shown in screenshot below.

Don't forget to tune Firebase Storage files 'Rules' depending on your usage. For demonstration purposes for this code recipe, I want to let user read images regardless of their authentication status. So, I'm making images readable to all as shown in screenshot below:

Step #3. Code Structure for loading image

I'll be using StatefulWidget to load image since I'll be toggling between two images available in my FirebaseStorage bucket. FutureBuilder widget is used to fetch the image from the Storage, and display the image depending on the connectionState and successful image retrieval.

class LoadFirbaseStorageImage extends StatefulWidget {
  @override
  _LoadFirbaseStorageImageState createState() =>
      _LoadFirbaseStorageImageState();
}

class _LoadFirbaseStorageImageState extends State<LoadFirbaseStorageImage> {
  ...

  Expanded(
    ...
    //Image Loading code goes here
    child: FutureBuilder(
            future: _getImage(context, image),
            builder: (context, snapshot) {
              if (snapshot.connectionState ==
                  ConnectionState.done)
                return Container(
                  height:
                      MediaQuery.of(context).size.height / 1.25,
                  width:
                      MediaQuery.of(context).size.width / 1.25,
                  child: snapshot.data,
                );

              if (snapshot.connectionState ==
                  ConnectionState.waiting)
                return Container(
                    height: MediaQuery.of(context).size.height /
                        1.25,
                    width: MediaQuery.of(context).size.width /
                        1.25,
                    child: CircularProgressIndicator());

              return Container();
            },
          ),
        ),
        ...
        //This is button to toggle image.
        loadButton(context),
}

_getImage(...) is responsible for directing the call to appropriate library targeted to specific platform. For example, native or web. FireStorageService is the interface that internally fetches image using the correct platform specific library.

Future<Widget> _getImage(BuildContext context, String image) async {
  Image m;
  await FireStorageService.loadFromStorage(context, image).then((downloadUrl) {
    m = Image.network(
      downloadUrl.toString(),
      fit: BoxFit.scaleDown,
    );
  });

  return m;
}

Checkout this plugins directory to familiarize yourself with the platform specific call re-direction.

File fire_storage_service.dart uses dart.library to decide on redirecting calls to native vs web implementation for FireStorageService.

export 'unsupported_storage.dart'
    if (dart.library.html) 'web_storage.dart'
    if (dart.library.io) 'mobile_storage.dart';

Any platform which is not web or native falls back to unsupported_storage.dart file:

import 'package:flutter/material.dart';

class FireStorageService extends ChangeNotifier {
  FireStorageService._();
  FireStorageService();

  static Future<dynamic> loadFromStorage(BuildContext context, String image) {
    throw ("Platform not found");
  }
}

Note: Checkout my previous article about plugins directory structure in details, and supporting web and native app's from single source code.

Step #4. Loading Image in Flutter Native App

Let's take a look at Native variant of FireStorageService in mobile_storage.dart file below:

import 'package:firebase_storage/firebase_storage.dart';
import 'package:flutter/material.dart';

class FireStorageService extends ChangeNotifier {
  FireStorageService();

  static Future<dynamic> loadFromStorage(BuildContext context, String image) async {
    return await FirebaseStorage.instance.ref().child(image).getDownloadURL();
  }
}

Step #5. Loading Image in Flutter Web App

Let's move on to Web variant of FireStorageService in web_storage.dart file below:

import 'package:firebase/firebase.dart';
import 'package:flutter/material.dart';

class FireStorageService extends ChangeNotifier {

  FireStorageService() {
    initializeApp(
        apiKey: "AIzaSyDEktNdn4CsMUxeOyVkPFBnaoAdNhcpEPc",
        authDomain: "fir-recipes-b5611.firebaseapp.com",
        databaseURL: "https://fir-recipes-b5611.firebaseio.com",
        projectId: "fir-recipes-b5611",
        storageBucket: "fir-recipes-b5611.appspot.com",
        messagingSenderId: "728428768644");
  }

  static Future<dynamic> loadFromStorage(BuildContext context, String image) async {
    var url = await storage().ref(image).getDownloadURL();
    return url;
  }
}

Please note that you would need to provide Firebase web project configuration to access storage() instance for web.

Checkout the source code for detailed implementation. As usual, this code recipe is linked from main flutter_widgets code recipes sample app.

Source code repo

Recipe source code is available here
Flutter Cookbook Project's source code is available here

References:

Configure Firebase project for Flutter Native Android app
Configure Firebase project for Flutter Native iOS app
Configuring Firebase project for Flutter Web app
Previous article about supporting web and native app's from single source code.

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Follow me at twitter

Animating using AnimatedPadding Flutter widget

2019-11-15T15:33:00-05:00

Introduction

AnimatedPadding widget is the animated version of the Padding widget.

In this article, we'll see how AnimatedPadding widget is used to animate an image in it. We'll observe animation behavior for various types of curves.

Target Audience: Beginner

Recipe: Animating an image in AnimatedPadding widget.

Focus Widget: AnimatedPadding

Goal: Animate an image inside AnimatedPadding using various types given AnimationCurves

AnimationCurves:

Checkout YouTube video:

Structure of `AnimatedPadding` widget

AnimatedPadding uses duration and curve properties to animate from previous value of inset to a newer value. The duration value controls how long animation would take whereas curve property's value provides the type of animation Curve

AnimatedPadding(
          padding: EdgeInsets.all(paddingValue),
          duration: Duration(seconds: 2),
          curve:
              dropDownValue != null ? dropDownValue.curveCubic : Curves.linear,
          child: Image.asset('assets/images/sea.jpg'),
        ),

Recipe's Code Structure

I'm using a drop down to choose the different type of curve. Animation curves used in this code recipe are available in the source code as well as here.

AnimatedPadding needs to be implemented inside a StatefulWidget since it can only animate when inset value is updated.

AnimationCurve dropDownValue holds the current selection from the AnimationCurves drop down widget.

class AnimatedPaddingDemo extends StatefulWidget {
  @override
  _AnimatedPaddingDemoState createState() => _AnimatedPaddingDemoState();
}

class _AnimatedPaddingDemoState extends State<AnimatedPaddingDemo> {
  AnimationCurve dropDownValue;
  bool selected = false;
  double paddingValue = 8.0;

  ...
}

Boolean selected keeps track of when 'Update padding' button is pressed or image is touched.

'Update padding' button next to dropDown widget. It updates the value of selected as below:

Widget playAnimation(BuildContext context) {
  return RaisedButton(
    color: Colors.blueAccent,
    child: Text("Update Padding"),
    onPressed: () => setState(() {
      selected = !selected;
      selected ? paddingValue = 40 : paddingValue = 8.0;
    }),
  );
}

Implementing `AnimatedPadding` widget

AnimatedPadding is wrapped around GestureDetector to let user start animation by touch in addition to pressing 'Update padding' button exclusively. User can choose one over another to start animation.

AnimatedPadding widget's default padding is 8.0. When user presses 'Update padding' button for a selected Curve type in dropDown widget, inset / padding updates to 20.0. AnimatedPadding updates its inset to new values with in 2 seconds as provided in duration attribute using current selection for curve property.

Widget animatedPaddingWidget(BuildContext context) {
  return GestureDetector(
    onTap: () {
      setState(() {
        selected = !selected;
        selected ? paddingValue = 20 : paddingValue = 8.0;
      });
    },
    child: Center(
      child: AnimatedPadding(
        padding: EdgeInsets.all(paddingValue),
        duration: Duration(seconds: 2),
        curve:
            dropDownValue != null ? dropDownValue.curveCubic : Curves.linear,
        child: Image.asset('assets/images/sea.jpg'),
      ),
    ),
  );
}

I encourage you to Checkout the code below, and play around with different types of Curve animations to pick an animation that would work best for you.

Source code repo

AnimatedPadding code recipe is available here
Source code for all other animation code recipes is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Animating using AnimatedPositioned Flutter widget

2019-11-14T13:33:00-05:00

Introduction

AnimatedPositioned widget is the animated version of the Positioned widget.

In this article, we'll see how AnimatedPositioned widget is used to animate an image in it. We'll observe animation behavior for various types of curves.

Target Audience: Beginner

Recipe: Animating an image in AnimatedPositioned widget.

Focus Widget: AnimatedPositioned

Goal: Animate an image inside AnimatedPositioned using various types given AnimationCurves

AnimationCurves:

Checkout YouTube video:

Structure of `AnimatedPositioned` widget

AnimatedPositioned uses duration and curve properties to animate from previous position to a new position. The duration value controls how long animation would take whereas curve property's value provides the type of animation Curve

AnimatedPositioned(
      width: selected ? 400.0 : 200.0,
      height: selected ? 200.0 : 400.0,
      duration: Duration(seconds: 2),
      curve: dropDownValue != null ? dropDownValue.curveCubic : Curves.linear,
      child: Image.asset('assets/images/sea.jpg'),
    ),

Recipe's Code Structure

I'm using a drop down to choose the different type of curve. Animation curves used in this code recipe are available in the source code as well as here.

AnimatedPositioned needs to be implemented inside a StatefulWidget since it can only animate when position is changed.

AnimationCurve dropDownValue holds the current selection from the AnimationCurves drop down widget.

class AnimatedPositionedDemo extends StatefulWidget {
  @override
  _AnimatedPositionedDemoState createState() => _AnimatedPositionedDemoState();
}

class _AnimatedPositionedDemoState extends State<AnimatedPositionedDemo> {
  AnimationCurve dropDownValue;
  bool selected = false;

  ...
}

Boolean selected keeps track of when 'Animate' button is pressed or image is touched.

'Animate' button next to dropDown widget. It updates the value of selected as below:

Widget playAnimation(BuildContext context) {
  return RaisedButton(
    color: Colors.blueAccent,
    child: Text("Animate"),
    onPressed: () => setState(() {
      selected = !selected;
    }),
  );
}

Implementing `AnimatedPositioned` widget

AnimatedPositioned widget's default position or width / height are 200.0 and 400.0 respectively. When user presses 'Animate' button for a selected Curve type in dropDown widget, position or width and height are updated to 400.0 and 200.0 respectively. AnimatedPositioned updates its position to a new value with in 2 seconds as provided in duration attribute using current selection for curve property.

Widget animatedPositionedWidget(BuildContext context) {
  return AnimatedPositioned(
    width: selected ? 400.0 : 200.0,
    height: selected ? 200.0 : 400.0,
    duration: Duration(seconds: 2),
    curve: dropDownValue != null ? dropDownValue.curveCubic : Curves.linear,
    child: Image.asset('assets/images/sea.jpg'),
  );
}

I encourage you to Checkout the code below, and play around with different types of Curve animations to pick an animation that would work best for you.

Source code repo

AnimatedPositioned code recipe is available here
Source code for all other animation code recipes is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Animating using AnimatedContainer Flutter widget

2019-11-13T23:33:00-05:00

Introduction

AnimatedContainer widget is the animated version of the Container widget.

In this article, we'll see how AnimatedContainer widget is used to animate an image in it. We'll observe animation behavior for various types of curves.

Target Audience: Beginner

Recipe: Animating a container widget using AnimatedContainer widget.

Focus Widget: AnimatedContainer

Goal: Animate an image inside AnimatedContainer using various types given AnimationCurves

AnimationCurves:

Checkout YouTube video:

Structure of `AnimatedContainer` widget

AnimatedContainer uses duration and curve properties to animate from previous values to new values of width, height, color, and alignment. duration value controls how long animation would take whereas curve property's value provides the type of animation Curve

AnimatedContainer(
        width: 100.0, //width of the container
        height: 100.0,
        color: Colors.blue,
        alignment: Alignment.center,
        duration: Duration(seconds: 2),
        curve: Curves.fastOutSlowIn,
        child: FlutterLogo(size: 75),
      ),

Recipe's Code Structure

I'm using a drop down to choose the different type of curve. Animation curves used in this code recipe are available in the source code as well as here.

AnimatedContainer needs to be implemented inside a StatefulWidget since its values are changed, and it provides animation while switching from old values to newer values.

AnimationCurve dropDownValue holds the current selection from the AnimationCurves drop down widget.

class AnimatedContainerDemo extends StatefulWidget {
  @override
  _AnimatedContainerDemoState createState() => _AnimatedContainerDemoState();
}

class _AnimatedContainerDemoState extends State<AnimatedContainerDemo> {
  AnimationCurve dropDownValue;
  bool selected = false;
  ...
}

Boolean selected keeps track of when Animate button is pressed or image is touched.

'Animate' button next to dropDown widget. It updates the value of selected as below:

Widget playAnimation(BuildContext context) {
  return RaisedButton(
    color: Colors.blueAccent,
    child: Text("Animate"),
    onPressed: () => setState(() {
      selected = !selected;
    }),
  );
}

Implementing `AnimatedContainer` widget

AnimatedContainer is wrapped around GestureDetector to let user start animation by touch in addition to pressing 'Animate' button exclusively. User can choose one over another to start animation.

AnimatedContainer widget's default width is 200 and default height is 400, and its alignment is topCenter. When user presses 'Animate' button for a selected Curve type in dropDown widget, width updates to 400, height updated to 200, and its alignment changes to center. AnimatedContainer updates to new values with in 2 seconds as provided in duration attribute using current selection for curve property.

Widget animatedContainer(BuildContext context) {
  return GestureDetector(
    onTap: () {
      setState(() {
        selected = !selected;
      });
    },
    child: AnimatedContainer(
      width: selected ? 400.0 : 200.0,
      height: selected ? 200.0 : 400.0,
      alignment: selected ? Alignment.center : AlignmentDirectional.topCenter,
      duration: Duration(seconds: 2),
      curve: dropDownValue != null ? dropDownValue.curveCubic : Curves.linear,
      child: Image.asset('assets/images/sea.jpg'),
    ),
  );
}

I encourage you to Checkout the code below, and play around with different types of Curve animations to pick an animation that would work best for you.

Source code repo

AnimatedContainer code recipe is available here
Source code for all other animation code recipes is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Implementing Slider & RangeSlider Flutter Widgets

2019-11-09T00:00:00-05:00

Introduction

Slider & RangeSlider widgets are used to select a value (Slider widget) or a range of values (RangeSlider widget) from a range of values.

In this code recipe, I'll demonstrate usage of both of these widget with help of scenario that is common to elementary school teachers. In the beginning of the school year, most of the language teachers curate a word list appropriate for the Grade and based on difficulty level of the words.

In today's code recipe, we'll make a Flutter app that'll display a random word from a given list of words. Teacher / user can choose the appropriate range of grades, and difficulty level for the given grade range. We'll make use of RangeSlider widget to select the Grade level ranges (from zero or Kindergarten to 5th grade), and Slider widget to choose difficulty level (three levels 1, 2, 3 represent Easy, Moderate and Advanced difficulty levels).

Target Audience: Beginner

Recipe: Implement RangeSlider and Slider widget to select Grade ranges and difficulty levels for the given words.

Focus Flutter plugin:

Goal: In this recipe, I'll go over following items:

Display a random English word from the given sample word list.
RangeSlider widget to represent the grades from 0 (K) to 5th.
Slider widget to represent three difficulty levels: Easy (1), Moderate (2), and Advanced (3).
Submit button for show the flow of app. Clicking on Submit button will rest the interface, and a word will be picked randomly from the sample wordlist.

This recipe is part of collection of my other code recipes. Starting page for recipes look like below:

Checkout YouTube video:

1. Displaying word for rating

Display a random English word from the given sample word list. I'm using a simple list of English words. In production application, this list either be stored in cache locally or streaming from backend depending your use case.

This is how it looks like in code recipe:

  var listOfWords = [
    'Them',
    'Up',
    'Web',
    'Come',
    'Play',
    'They',
    'So',
    'Construct',
    'Tournament',
    'Glide'
  ];

  var word = 'Their';

word variable keeps the currently displayed word ready for rating.

Showing current word inside Card widget:

Center(
  child: Card(
    elevation: 1.0,
    child: Padding(
      padding: const EdgeInsets.all(16.0),
      child: Text(
        word,
        style: TextStyle(
            fontSize: 34.0, fontWeight: FontWeight.normal),
      ),
    ),
  ),
),

Once Submit button is called, it'll be randomly picked from listOfWords and updated.

2. Implementing RangeSlider widget

RangeSlider widget to represent the grades from 0 (K) to 5th.

Remember that widget's values can only be updated for Stateful widget.

I chose RangeSlider to represent different grades because, one word can be appropriate for a multiple grades. However, difficulty might vary from one grade to another. For example word 'Their' can be appropriate for grade 2nd thru 5th. However, difficulty level for 2nd grade can be 'Advanced', and 'Easy' for 5th grade. That's the reason range selection makes sense for grades whereas difficulty can be represented with one of the number from three possibilities: 1 (Easy), 2 (Moderate), or 3 (Advanced).

Since we're representing grades K thru 5 in numbers : 0, 1, 2, 3, 4, and 5, min for RangeSlider is 0 and max is 5. We want discrete selection of grades, so we'll use divisions attribute. That means there 2.5 can not be selected for a grade.

labels property displays the range of selection. RangeLabels is required to display labels for RangeSlider. It requires the start and end values of the range: RangeLabels('${gradesRange.start}', '${gradesRange.end}').

class SliderDemo extends StatefulWidget {
  @override
  _SliderDemoState createState() => _SliderDemoState();
}

class _SliderDemoState extends State<SliderDemo> {
  var gradesRange = RangeValues(0, 5);

  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text("Sliders (Guess the Word's level)"),
      ),
      body: Stack(
        children: <Widget>[
        ...,
        RangeSlider(
          min: 0,
          max: 5,
          divisions: 5,
          labels: RangeLabels(
              '${gradesRange.start}', '${gradesRange.end}'),
          values: gradesRange,
          onChanged: (RangeValues value) {
            setState(() {
              gradesRange = value;
            });
          },
        ),
        ...,
        ],
        ),
  }

}        
}

3. Implementing Slider widget

Slider widget to represent three difficulty levels: Easy (1), Moderate (2), and Advanced (3).

Slider widget expects values in double. I'm using 2 (Moderate) as default difficulty level for a chosen word. Since there are only three possible values for difficulty, min is set to 1, and max is 3. Similar to grades range, we want difficulty levels discrete as well. A word can fall in one of the 3 categories. We get two divisions by setting divisions property to 2. Setting label property to current selected value makes it informative for the user to make their selection.

Please note that I'm using Slider.adaptive widget. This widget adapts to the target platform.

class SliderDemo extends StatefulWidget {
  @override
  _SliderDemoState createState() => _SliderDemoState();
}

class _SliderDemoState extends State<SliderDemo> {
  double _diffLevel = 2;

  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text("Sliders (Guess the Word's level)"),
      ),
      body: Stack(
        children: <Widget>[
        ...,
        Slider.adaptive(
          value: _diffLevel.toDouble(),
          onChanged: (double newValue) {
            setState(() {
              _diffLevel = newValue;
            });
          },
          min: 1,
          max: 3,
          divisions: 2,
          label: _diffLevel.toString(),
        ),
        ...,
        ],
        ),
  }
}        
}

4. Submit button (Resetting interface)

I added Submit button for completeness of workflow of page. Clicking on Submit button will rest the interface, and a word will be picked randomly from the sample wordlist.

Here's what happens when user clicks Submit button:

child: RaisedButton(
  ...
  child: Text(
    "Submit",
    style: TextStyle(fontSize: 16.0),
  ),
  onPressed: () {
    setState(() {
      var randomNumber = new Random().nextInt(9);
      word = listOfWords[randomNumber];
      _diffLevel = 2;
      gradesRange = RangeValues(0, 5);
    });
  },
),

Note: Interface's values are being reset inside setState(..) function.

Source code repo

Recipe source code is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Implementing Voice input for Search action in AppBar

2019-10-10T00:00:00-04:00

Voice Search in AppBar

This recipe is second part of Implementing Search action in AppBar tutorial. Today, we'll use our voice to enter the search term rather typing text in search bar.

Target Audience: Beginner

Recipe: Implementing Voice input for Search action in AppBar using Flutter for Android and iOS mobile apps.

Focus Flutter plugin: SpeechRecognition

Goal: In this recipe, I'll go over following items:

Adding a mic icon in SearchBar
Handling permissions: Using permission_handler plugin to request audio permissions from user at Android and iOS platforms.
Integrating speech recognition using SpeechRecognition Flutter plugin

Checkout in action:

Lets's get started!

Dependencies: `pubspec.yaml`

We'll need two new dependencies:

SpeechRecognition Plugin is needed to capture the voice input from user and convert it into text/transcript. This transcript is used to run search in word list and display the result.
Permission Handler Plugin is needed to ask for platform specific permissions required to capture voice input.

dependencies:
  speech_recognition: ^0.3.0+1
  permission_handler: ^3.2.0

Adding mic icon in SearchBar

Mic icon in search bar:

First, we'll add a microphone icon in AppBar's actions. Please note the new code _buildVoiceInput(..) responsible for accepting voice input. Refer to previous article for other details.

@override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        automaticallyImplyLeading: false,
        title: Text('Word List'),
        actions: <Widget>[
          _buildVoiceInput(
            onPressed: _speechRecognitionAvailable && !_isListening
                ? () => start()
                : () => stop(),
            label: _isListening ? 'Listening...' : '',
          ),
          //Adding the search widget in AppBar
          IconButton(
            tooltip: 'Search',
            icon: const Icon(Icons.search),
            //Don't block the main thread
            onPressed: () {
              showSearchPage(context, _searchDelegate, transcription);
            },
          ),
        ],
      ),
      ...
   }

   Widget _buildVoiceInput({String label, VoidCallback onPressed}) =>
    new Padding(
        padding: const EdgeInsets.all(12.0),
        child: Row(
          children: <Widget>[
            FlatButton(
              child: Text(
                label,
                style: const TextStyle(color: Colors.white),
              ),
            ),
            IconButton(
              icon: Icon(Icons.mic),
              onPressed: onPressed,
            ),
          ],
        ));

Handling permissions

Android and iOS platforms need user's consent to capture voice input. permission_handler plugin helps to request audio permissions from user at both platforms.

It shows user that voice recording permissions are required, and present a permissions dialog like below:

Android:

iOS:

Android:

Make sure that you've following permissions in AndroidManifest.xml:

<uses-permission android:name="android.permission.INTERNET"/> <uses-permission android:name="android.permission.RECORD_AUDIO" />

iOS: Add following keys in Info.plist. Feel free to modify text description accordingly.

Key: Privacy - Microphone Usage Description. Value: This application needs to access your microphone.
Key: Privacy- Speech Recognition Usage Description. Value: This application needs the speech recognition permission.

Once AndroidManifest.xml and Info.plist in place, next step is to ask for permissions from Flutter app, main.dart in our case like below:

void requestPermission() async {
  PermissionStatus permission = await PermissionHandler()
      .checkPermissionStatus(PermissionGroup.microphone);

  if (permission != PermissionStatus.granted) {
    await PermissionHandler()
        .requestPermissions([PermissionGroup.microphone]);
  }
}

Integrating SpeechRecognition

I'll be using SpeechRecognition Flutter plugin to integrate capture voice input for search term. Speech recognizer related code needs to go inside a Stateful widget. In our case, it goes under _SearchAppBarRecipeState. _speech holds the reference to SpeechRecognition instance. _speechRecognitionAvailable flag gets updated based on availability of speech recognizer. _isListening is set to true when app is activated to listen to user input. Lastly, transcription is voice input transcribed int text. This is the text that will be used to run search against.

class _SearchAppBarRecipeState extends State<SeachAppBarRecipe> {
  //speech
  SpeechRecognition _speech;
  bool _speechRecognitionAvailable = false;
  bool _isListening = false;

  String transcription = '';
  ...
}

Initializing SpeechRecognizer in initState() method:

@override
void initState() {
  ...
  activateSpeechRecognizer();
}

Speech recognizer is activated with callbacks. Few of the important callbacks are:

onSpeechAvailability(bool result): It updates the status of the availability of speech in _speechRecognitionAvailable flag.
onCurrentLocale(String locale): Updates the SpeechRecognizer's locale for the language that it is expected to be listening to.
onRecognitionStarted(): It's called when SpeechRecognizer has been listening to user voice input actively. It updates _isListening flag to true.
onRecognitionResult(String text): This is where the actual magic happens. Voice input is transcribed to English text. We're using only 'en_US' locale for this code recipe. Once the transcribed text is available, it's sent over to search page like below:

showSearchPage(context, _searchDelegate, transcription);

Transcribed text gets populated in search bar. When user accepts the search word by hitting enter, search result is displayed on result page similar to how it was displayed in previous tutorial.

onRecognitionComplete(): This callback is called when user stops talking. At this point, _isListening flag is set to false.

void activateSpeechRecognizer() {
  requestPermission();

  _speech = new SpeechRecognition();
  _speech.setAvailabilityHandler(onSpeechAvailability);
  _speech.setCurrentLocaleHandler(onCurrentLocale);
  _speech.setRecognitionStartedHandler(onRecognitionStarted);
  _speech.setRecognitionResultHandler(onRecognitionResult);
  _speech.setRecognitionCompleteHandler(onRecognitionComplete);
  _speech
      .activate()
      .then((res) => setState(() => _speechRecognitionAvailable = res));
}

void start() => _speech
    .listen(locale: 'en_US')
    .then((result) => print('Started listening => result $result'));

void cancel() =>
    _speech.cancel().then((result) => setState(() => _isListening = result));

void stop() => _speech.stop().then((result) {
      setState(() => _isListening = result);
    });

void onSpeechAvailability(bool result) =>
    setState(() => _speechRecognitionAvailable = result);

void onCurrentLocale(String locale) =>
    setState(() => print("current locale: $locale"));

void onRecognitionStarted() => setState(() => _isListening = true);

void onRecognitionResult(String text) {
  setState(() {
    transcription = text;
    showSearchPage(context, _searchDelegate, transcription);
    stop(); //stop listening now
  });
}

void onRecognitionComplete() => setState(() => _isListening = false);

Listening to user's voice:

Converting speech to text, and using text for searching in word list:

Displaying result:

Source code repo: Recipe source code is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Migrating to Flutter 1.9: Implementing Cross-platform Firebase Login in Flutter Apps

2019-09-23T00:00:00-04:00

Background

I've been experimenting with Flutter Web (aka Hummingbird earlier) since it was announced in Google IO 2019.

I remember submitting pull request to add instructions for running Flutter sample web apps. Since then I liked the challenge of exploring fast paced and ever changing Flutter Web.

I wrote couple of articles to design and implement a landing page in Flutter which can work seamlessly on all three platforms: Android, iOS and Web. I kept on improving upon this landing page to include login using Firebase, FactsBot, themes, and so on.

Please refer to previous related articles below:

Checkout the companion video:

Introduction

In this article, I'll show you how Flutter 1.9 release makes developing cross-platform Flutter applications simple while maximizing code reuse. I'll be using my previous Flutter-to-Fly sample app to demonstrate this transition to Flutter 1.9.

Migrating project to Flutter 1.9

There is pretty good documentation on migrating existing project to Flutter 1.9 and / or creating a new Flutter project available on official Flutter website. Basically, you would need to run these following commands in one directory level up of your project directory:

  $ flutter channel master
  $ flutter upgrade
  $ flutter config --enable-web
  $ cd <into project directory>
  $ flutter create .
  $flutter run -d chrome

NOTE: In case you run into White screen issue, you may want to change your Flutter channel to flutter channel dev.

Running X-platform apps from Android Studio

Starting from Flutter 1.9, you can run apps on Android, iOS, and Chrome right from Android Studio:

Deploying Web App

Deploying Web App is just a command away:

 $ flutter build web

Above command will generate a build folder in the root directory. Copy its contents into public directory of your hosting site.

Launching URL(s)

So far, we kept web and native codebase in separate branches to manage launching URL in web and mobile environments differently. Flutter 1.9 makes it possible to be able to keep both (web and mobile/native) codebase in one branch, and pick the right implementation by detecting the platform using dart.library.html for web and dart.library.io for mobile platform.

You can organize your code base for plugins as below as recommended by Flutter team:

Above screenshot shows two plugins:

url_launcher: Managing launching URLs based on target platform. Refer to complete source code here
firetop: Manages firebase related functionality for mobile and web platforms. We'll dive deeper into this plugin in next section. Refer to complete source code here.

pubspec.yaml:

Following dependencies are needed for launching URLs from Flutter app.

dependencies:
  universal_html: ^1.1.0
  url_launcher: ^5.1.2

Let's see contents of url_launcher.dart below. This is where target platform is detected and appropriate implementation is used.

export 'unsupported.dart'
    if (dart.library.html) 'web.dart'
    if (dart.library.io) 'mobile.dart';

Firebase login functionality

Flutter team is working on fb_auth plugin to provide cross-platform Firebase support.

pubspec.yaml:

Following dependency is needed for adding cross-platform support for Firebase.

dependencies:

  fb_auth: 0.0.2+1

Let's checkout fire_auth_service.dart below. Please refer to source code in Gihub repo to refer other files.

export 'unsupported.dart'
    if (dart.library.html) 'web.dart'
    if (dart.library.io) 'mobile.dart';

You would notice that web.dart and mobile.dart are very similar and use FBAuth() to access Firebase functionality. We still need to keep them separate because not everything is available in fb_auth plugin. For example, FireStore support is missing for Flutter Web.

Conclusion

I kept this article short to give a quick update on most important changes that are happening in Flutter Web world. This article gave a peek into getting started with merging Flutter Web code branches into Native code, and how to target platform specific code. We saw how URLs can be launched for Web and Mobile apps using the same code base. Lastly, we covered integrating with Firebase from the one code base.

Keep Fluttering !

Source code

Flutter-to-Fly sample app's source code is available here

References/Credits:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Using ColorFiltered widget in Flutter Apps

2019-09-17T00:00:00-04:00

Target Audience: Beginner

Recipe: Using ColorFiltered widget to update quiz card feedback screen's background color.

Focus Widget: ColorFiltered Widget

Goal: Update BottomSheet feedback widget's background color to reflect status of the correct or wrong answer to quiz question. A shade of red color is generated using color filter for wrong selection and green shade is for right answer.

NOTE: At the moment, ColorFiltered widget crashes on Chrome. Please refer to this issue at Flutter Github.

iOS QuizPage:

Android QuizPage:

Checkout the companion video tutorial:

Lets's go!

ColorFilter Widget is added to Flutter 1.9 release. This widget allows to generate dynamic and vibrant shades depending on the chosen blend modes, a part of dart.ui in Flutter framework's painting.dart file. I'm using BlendMode.hue mode to mix red and green colors with QuizPage's Colors.lightBlueAccent color.

NOTE: ColorFilter doesn't seem to work on Web. Refer to a related issue here.

Running the sample code

There are two ways that you can try out sample code in this recipe.

Running only QuizzieDemo: This sample can be run independently. Make sure that you have void main() => runApp(QuizzieDemo()); at the top of the quizze_demo.dart file.
Running as part of code recipe app: Should you choose this option, you can see other code recipes listed in home page.

Code Structure

There are two files: 1. quizze_demo.dart: Contains the entry point to the sample code recipe.

import 'package:flutter/material.dart';
import 'package:flutter_widgets/quizzie/quizze_page.dart';

//Note: Use code below to just run this demo.
// OR comment it out if you want to run it on Web as part of recipe sample app
void main() => runApp(QuizzieDemo());

class QuizzieDemo extends StatefulWidget {
  @override
  _QuizzieDemoState createState() => _QuizzieDemoState();
}

class _QuizzieDemoState extends State<QuizzieDemo> {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      home: QuizPage(),
    );
  }
}

quizze_page.dart: Contains the code related to QuizPage, and ColorFilter for updating background color of feedback widget: BottomSheet.

Let's explore QuizPage Stateless widget in detail. There are three parts to QuizPage interface: * Image widget for the quiz question. * Text widget to describe question. * Expanded widget to wrap answer options. We are using Expanded widget to fill the available space on the screen. All the answer options will be added as child under Expanded widget. QuizOptions() widget encapsulates choices / options for the quiz answers.

Check out the code QuizPage widget below:

class QuizPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      backgroundColor: Colors.white,
      body: Column(
        children: <Widget>[
          Container(
            padding: EdgeInsets.only(top: 50, left: 20, right: 20, bottom: 20),
            child: Column(
              crossAxisAlignment: CrossAxisAlignment.start,
              children: <Widget>[
                Image.asset(
                  "assets/images/tomato.jpg",
                ),
                Text(
                  "Is tomato a fruit or vegetable ?",
                  style: TextStyle(
                    color: Colors.lightBlueAccent,
                    fontWeight: FontWeight.bold,
                    fontSize: 30,
                  ),
                ),
              ],
            ),
          ),
          SizedBox(
            height: 20,
          ),
          Expanded(
            child: Container(
              decoration: BoxDecoration(
                color: Colors.lightBlueAccent,
                borderRadius: BorderRadius.only(
                    topLeft: Radius.circular(20),
                    topRight: Radius.circular(20)),
              ),
              child: QuizOptions(),
            ),
          )
        ],
      ),
    );
  }
}

Now, it's time to build QuizOptions widget for quiz options. There can only be one answer selected at a time, so it makes sense to use RadioListTile to represent each answer option. QuizOptions must be a StatefulWidget since it's going to show feedback to user based on the state of the choice selection.

class QuizOptions extends StatefulWidget {
  @override
  _QuizOptionsState createState() => _QuizOptionsState();
}

Managing state takes place in _QuizOptionsState class. All options are wrapped in ListView. Using enum for Options make it easier to use in code.

enum Options { fruit, veggie, none }

_QuizOptionsState:

class _QuizOptionsState extends State<QuizOptions> {
  Options selection = Options.none;

  @override
  Widget build(BuildContext context) {
    return ListView(
      children: <Widget>[
        RadioListTile(
          title: Text(
            "Fruit",
            style:
                TextStyle(fontSize: 30, color: Colors.white, letterSpacing: 3),
          ),
          value: Options.fruit,
          groupValue: selection,
          onChanged: (Options value) =>
              setState(() => showAnswer(context, value)),
        ),
        RadioListTile(
          title: Text(
            "Vegetable",
            style:
                TextStyle(fontSize: 30, color: Colors.white, letterSpacing: 3),
          ),
          value: Options.veggie,
          groupValue: selection,
          onChanged: (Options value) =>
              setState(() => showAnswer(context, value)),
        )
      ],
    );
  }

...
}

When a selection is made, RadioListTile's 'onChanged method is invoked, and passes the current selection into showAnswer method as below. showAnswer updates the current selection to the option's value passed, and use showModalBottomSheet to show a modal Material design bottom sheet.

...

void showAnswer(BuildContext context, Options value) {
  selection = value;
  showModalBottomSheet(context: context, builder: buildBottomSheet);
}

...

showModalBottomSheet picks the explanation for the current choice, and uses ColorFiltered widget to apply color filter based on the right and wrong choice. ColorFiltered widget use FeedbackWidget as its child to display the feedback message. ColorFilter.mode(...) uses BlendMode.hue and response specific source color (Colors.greenAccent for correct response, and Colors.redAccent for wrong response). Its child widget FeedbackWidget has Colors.lightBlueAccent - destination color. ColorFiltered widget can apply filters based on its colorFilter attribute. It can blend source color with destination color based on the BlendMode, which is BlendMode.hue in our case.

Widget buildBottomSheet(BuildContext context) {
  String explanation = "";
  if (selection == Options.fruit) {
    explanation = "You got it! Tomato is a fruit since it has seeds in it.";

    return ColorFiltered(
      colorFilter: ColorFilter.mode(Colors.greenAccent, BlendMode.hue),
      child: FeedbackWidget(explanation: explanation),
    );
  } else {
    explanation =
        "While many people believe a tomato is a vegetable, a tomato has seeds and thus is actually a fruit.";

    return ColorFiltered(
      colorFilter: ColorFilter.mode(Colors.redAccent, BlendMode.hue),
      child: FeedbackWidget(explanation: explanation),
    );
  }
}

FeedbackWidget is a StatelessWidget. It shows feedback text message in a Container widget, with a BoxDecoration color as Colors.lightBlueAccent.

class FeedbackWidget extends StatelessWidget {
  const FeedbackWidget({
    Key key,
    @required this.explanation,
  }) : super(key: key);

  final String explanation;

  @override
  Widget build(BuildContext context) {
    return Container(
      height: 150,
      decoration: BoxDecoration(
          color: Colors.lightBlueAccent,
          //optional radius
          borderRadius: BorderRadius.only(
              topRight: Radius.circular(10), topLeft: Radius.circular(10))),
      child: Padding(
        padding:
            const EdgeInsets.only(top: 10, left: 10, right: 10, bottom: 10),
        child: Text(
          explanation,
          style: TextStyle(
              fontSize: 25,
              color: Colors.white,
              wordSpacing: 5,
              letterSpacing: 1),
        ),
      ),
    );
  }
}

And, you're done !

Source code repo: Recipe source code is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Follow me at twitter

Dart cheat-sheet for Kotlin (Android) developers

2019-09-16T00:00:00-04:00

This post is my effort to provide my fellow Kotlin developers a hand to pick up on Dart. Idea is to provide equivalent solution in both languages. The demonstrated code is not the only solution for a particular problem, but just one way of doing things. Style of article is to perform a task in both languages. For example, print "Hello World!" in Kotlin and Dart.

I've used Kotlin Playground and DartPad to run and play around with languages.

Task: Print "Hello World"

Kotlin:

fun main() {
  println("Hello World")
}

Output:

Hello World

Dart:

void main() {
  print("Hello World");
}

Output:

Hello World

Task: How to delete duplicates in a List

Kotlin:

fun main() {
  var myList = listOf('A', 'A', 'B', 'C', 'A', 'D', 'B', 'C')
  myList = myList.distinct()
  print(myList)
}

Output:

[A, B, C, D]

Another way in Kotlin. Note usage of arrayOf() instead listOf.

fun main() {
  val myList = arrayOf('A', 'A', 'B', 'C', 'A', 'D', 'B', 'C')
  val noDupsList = myList.distinct()
  print(noDupsList)
}

Output:

[A, B, C, D]

Dart:

//Delete duplicates from myList
void main() {
  var myList = ['A', 'A', 'B', 'C', 'A', 'D', 'B', 'C'];
  myList = Set.of(myList).toList();
  print(myList);
}

Output:

[A, B, C, D]

Task:

Kotlin:

Output:

Dart:

Output:

Task:

Kotlin:

Output:

Dart:

Output:

Happy coding :)

Useful Links

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Follow me at twitter

Implement Flutter themes using Provider

2019-09-12T00:00:00-04:00

Checkout related articles:

Target Audience: Beginner

Recipe: Toggle Flutter themes from one type to another using Provider dependency injection and state management package.

Focus Widget: Provider plugin

Goal: Implementing themes using Provider plugin. Implement a simple UI with an image, text and a button to switch themes. Page's default theme is light. Clicking on "Switch Theme" button will apply dark theme to page, and vice versa.

Light Theme:

Dark Theme:

Checkout the companion video tutorial:

What is Provider

Provider is a plugin/package that provides dependency injection and state management solution for a Flutter App. It's built with robust and scalable Flutter widgets.

Step #1. `pubspec.yaml`

Add package dependency in pubspec.yaml:

dependencies:
  flutter:
    sdk: flutter

  #Dependency for Provider plugin
  provider: ^3.1.0 #ChangeNotifier, Consumer, Providers

Step #2. Implement theme ChangeNotifier

I'll be using two themes: Light and Dark. Let's use enum to declare these two themes:

enum MyThemes { light, dark }

Now, I need a ChangeNotifier that'll notify my app about the change occurred in theme preference.

class ThemesNotifier with ChangeNotifier {}

Next comes defining ThemeData for light and dark themes:

static final List<ThemeData> themeData = [
  ThemeData(
      brightness: Brightness.light,
      primaryColor: Colors.blue,
      accentColor: Colors.lightBlueAccent),
  ThemeData(
      brightness: Brightness.dark,
      primaryColor: Colors.orange,
      accentColor: Colors.yellowAccent)
];

Let's initialize default MyThemes and ThemeData:

MyThemes _currentTheme = MyThemes.light;
ThemeData _currentThemeData = themeData[0];

Lastly, setters and getters to update and access MyThemes and ThemeData:

void switchTheme() => currentTheme == MyThemes.light
    ? currentTheme = MyThemes.dark
    : currentTheme = MyThemes.light;

set currentTheme(MyThemes theme) {
  if (theme != null) {
    _currentTheme = theme;
    _currentThemeData =
        currentTheme == MyThemes.light ? themeData[0] : themeData[1];

    //Notifies the theme change to app    
    notifyListeners();
  }
}

get currentTheme => _currentTheme;
get currentThemeData => _currentThemeData;

Step #3. Notifying theme change to App

Sample App 'Themes Demo''s build(...) method uses theme attribute to assign ThemeData to app like below. Provider.of<ThemesNotifier>(context).currentThemeData is notified about a theme change happened in ThemesNotifier's switchTheme() method.

@override
Widget build(BuildContext context) {
  return MaterialApp(
      theme: Provider.of<ThemesNotifier>(context).currentThemeData,
      home: Scaffold(
        appBar: AppBar(
          title: Text("Themes Demo"),
        ),
        body: body(),
      ));
}

Theme change is requested from Switch Theme button :

RaisedButton(
  child: Text("Switch Theme"),
  onPressed: () {
    Provider.of<ThemesNotifier>(context).switchTheme();
  },
),

That's all !

Running on Flutter Web

Note: Flutter Web project setup has been changed since Flutter 1.9 release.

Please follow the direction on setting up Flutter Web project here.

Source code repo: Recipe source code is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Follow me at twitter

Implementing Login in Flutter Web (Hummingbird)

2019-09-10T00:00:00-04:00

Background

In this article, we'll make use of FirebaseAuth to implement login functionality in Flutter-to-Fly WebApp built using Flutter Web - Hummingbird. Design has been evolved since I wrote my first article about Designing Cross platform Flutter prototype for Landing Page (Web-Hummingbird, Android, iOS). This article focuses on implementing Login functionality in Hummingbird only. Please refer to this youtube video for implementing same login functionality in Android & iOS.

We'll implement LogIn button shown below:

Please refer to previous related articles below:

Checkout the companion video:

Introduction

In this article, we'll make our login button work. I'll use Firebase authentication to implement email and password authentication. First, setup Firebase Project as mentioned here. We need to add configuration details in Flutter app to be able to communicate with Firebase.

We'll add two more pages to WebApp.

LogIn Page: Clicking on "LogIn" button will take user to LogIn Page where either they can login using their credentials or register. Registering a user creates a user record in FireStore.
User Profile Page: Logged in users can see their display name, profile picture placeholder, and SignOut button. This is only for demonstration purposes, and doesn't do much at this point.

`pubspec.yaml`

Following dependencies need to be added to pubspec.yaml to interact with Firebase. Provider package is used for dependency injection and state management.

dependencies:
  firebase: any
  service_worker: ^0.2.0
  googleapis_auth: ^0.2.3+5
  provider: any

dependency_overrides:
  provider:
    git:
      url: https://github.com/kevmoo/provider
      ref: flutter_web
  firebase:
    git:
      url: https://github.com/FirebaseExtended/firebase-dart

Web entry point: As we know that Flutter Web apps' entry point is web/main.dart which is compiled to javascript, and referred from web/index.html. Let's checkout code in both files:

web/main.dart:

main() async {
  try {
    await config();

    fb.initializeApp(
      apiKey: apiKey,
      authDomain: authDomain,
      databaseURL: databaseUrl,
      storageBucket: storageBucket,
      projectId: projectId,
    );

    await ui.webOnlyInitializePlatform();
    app.main();
  } on fb.FirebaseJsNotLoadedException catch (e) {
    print(e);
  }
}

web/index.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title></title>
    <script src="https://www.gstatic.com/firebasejs/6.4.0/firebase-app.js"></script>
    <script src="https://www.gstatic.com/firebasejs/6.4.0/firebase-firestore.js"></script>
    <script src="https://www.gstatic.com/firebasejs/6.4.0/firebase-auth.js"></script>
    <script src="https://www.gstatic.com/firebasejs/6.4.0/firebase-storage.js"></script>
    <script defer src="main.dart.js" type="application/javascript"></script>
</head>
<body>
</body>
</html>

Firebase Configuration:

fb.initializeApp needs Firebase App's configuration parameters. We need to add this information in package:firebase/src/assets/config.json file. There's a sample config.json.sample file available for you for reference:

{
  "_FYI": "https://firebase.google.com/docs/web/setup",
  "_COPY_TO": "config.json",
  "API_KEY": "TODO",
  "AUTH_DOMAIN" : "TODO",
  "DATABASE_URL": "TODO",
  "STORAGE_BUCKET": "TODO",
  "PROJECT_ID": "TODO",
  "MESSAGING_SENDER_ID": "TODO",
  "SERVER_KEY": "TODO",
  "VAPID_KEY": "TODO",
}

Get parameters from Firebase console for your project, and update values in config.json.

LogIn Page

I'll not be explaining the UI code in this tutorial. However, please take a look at source code. Feel free to reach out to me if you need explanation with any part.

LogIn Form:

Register Form:

Authenticating using FirebaseAuthService:

FirebaseAuthService is a ChangeNotifier, which means if any sign-in or sign-out happens in this class, all other subscribed classes are notified. I've abstracted all APIs using BaseAuthService.

abstract class BaseAuthService with ChangeNotifier {
  Future<User> currentUser();
  Future<User> signIn(String email, String password);
  Future<User> googleSignIn();
  Future<User> updateUser(User user);
  Future<User> createUser(
      String firstName, String lastName, String email, String password);
  Future<void> signOut();
}

FirebaseAuthService extends BaseAuthService:

class FireAuthService extends BaseAuthService {
  final Auth _firebaseAuth = fb.auth();

  //Get currently logged-in user
  @override
  Future<User> currentUser() async {
    return await _firebaseAuth.currentUser;
  }

  //Sign-in using email and password, notifies all subscribers.
  @override
  Future<User> signIn(String email, String password) async {
    try {
      var auth =
          await _firebaseAuth.signInWithEmailAndPassword(email, password);

      notifyListeners();
      return auth.user;
    } catch (e) {
      throw Exception(e);
    }
  }

  //This method is called from register form. A user account is created in FirebaseAuth
  @override
  Future<User> createUser(
      String firstName, String lastName, String email, String password) async {
    var auth =
        await _firebaseAuth.createUserWithEmailAndPassword(email, password);

    var info = fb.UserProfile();
    info.displayName = '$firstName $lastName';
    await auth.user.updateProfile(info);

    updateUser(auth.user);

    return auth.user;
  }

  //A record is created at Firestore to keep track of all personalized data for each user.
  @override
  Future<User> updateUser(User user) async {
    final CollectionReference ref = fb.firestore().collection('users');

    String displayName = user.displayName;
    String photoUrl = user.photoURL;

    if (displayName == null) {
      displayName = "No Name yet";
    }

    if (photoUrl == null) {
      photoUrl = "";
    }

    var newData = {
      'uid': user.uid,
      'displayName': displayName,
      'photoUrl': photoUrl,
      'email': user.email,
      'lastActive': DateTime.now()
    };

    await ref.doc(user.uid).set(newData, SetOptions(merge: true));

    return user;
  }

  //Sign-out
  @override
  Future<void> signOut() async {
    _firebaseAuth.signOut();
    notifyListeners();
  }

  @override
  Future<User> googleSignIn() async {
    //TODO
  }
}

Checking for a logged-in user: Following code will check-in whether a user is already signed-in. If so, then UserProfilePage is displayed. Otherwise LogInPage is rendered.

return FutureBuilder<User>(
      future: Provider.of<FireAuthService>(context).currentUser(),
      builder: (context, AsyncSnapshot<User> snapshot) {
        if (snapshot.connectionState == ConnectionState.done) {
          if (snapshot.error != null) {
            return Text(snapshot.error.toString());
          }

          if (snapshot.hasData) {
            return UserProfilePage(context, snapshot.data);
          }

          return LogInPage(title: 'Login');
        } else {
          return Container(
            child: CircularProgressIndicator(),
          );
        }
      },
    );

User Profile Page

A UserProfilePage displays very basic information about the logged-in user. Right now, it shows: welcoming user with their email used as display name, placeholder for profile picture and sign-out button. Please refer to source code for details of implementing user interface.

A note on iOS Firebase integration

You may run into trouble building your code for iOS complaining about Firebase imports as shown in screenshot below:

Solution: I found this StackOverflow post useful to debug and fix this issue:

Conclusion

We learned how to implement Firebase authentication in Flutter Web / Hummingbird for 'Login' button in our demo web app. We overviewed dependencies, and ChangeNotifier responsible for authentication, registering and creating user, and creating a user record in FireStore. Please refer to code below for Web and Native (Android & iOS) implementations.

Keep Fluttering !

Source code

Hummingbird / Flutter Web implementation's source code is available here
Android & iOS implementation's source code is available here

References/Credits:

Image Credits

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Custom switch widget for accepting Privacy Policy in Flutter Apps

2019-08-30T00:00:00-04:00

Target Audience: Beginner

Recipe: Implementing Custom Switch Widget to accept privacy policy from Settings screen.

Focus Widget: Switch Widget

Goal: In our demo app, we'll implement a custom stateless widget HyperlinkedLabelSwitch. It'll contain two main visual parts:

Label 'Privacy Policy' aligned to start. Clicking / tapping on this label will open url in a WebView. I'll be using a Google Doc for sample privacy policy accessible via a hyperlink.
Toggle switch aligned to the end of the screen. On switch means privacy policies are accepted. This accepted status is updated as 'Privacy Policy (Accepted)' in left label. Toggling this switch to "off" update text label back to 'Privacy Policy'.

Screenshot of Privacy policy loaded in WebView:

Screenshot of updated text label after accepting privacy policy:

Checkout the companion video tutorial:

Implementing Custom Switch Widget : `HyperlinkedLabelSwitch`

We'll be creating custom switch widget with clickable text label and switch. Screenshot of custom widget in 'off' mode (Privacy privacy is not accepted):

Screenshot of custom widget in 'on' mode (Privacy privacy accepted):

Step #1. Create a class HyperlinkedLabelSwitch extending StatelessWidget. This widget has following members:

label: Text displaying 'Privacy Policy'
hyperlink: Web link (url) to privacy policy document.
selected: Boolean value to determine whether policy is accepted or not.
onChange: Function to be assigned to Switch widget's onChanged: property.
padding: This is the padding around the custom widget. Ability to pass this value (rather hard coding) from parent make custom widget reusable.

class HyperlinkedLabelSwitch extends StatelessWidget {
  final String label;
  final String hyperlink;
  final bool selected;
  final Function onChange;
  final EdgeInsets padding;
}

Now, let's build the custom widget that contains a clickable label and toggle switch. We need a padding around this widget for visual appeal. We'll use the padding passed from parent as padding parameter. I'm using Row widget to put label and toggle switch next to each other. Clickable label stays at the start of the screen, so it'll be the first child, and Switch widget is placed as second children to the Row widget. Since label consist of text, and it gets updated when user accepts the privacy policy, so we need it keep this widget flexible. We need to allow it to expand to claim the available space. That's why we'll use Expand widget to claim empty area.

@override
Widget build(BuildContext context) {
  return Padding(
    padding: padding,
    child: Row(
      children: <Widget>[
        Expanded(),
        Switch()
      ],
    ),
  );
}

I'll make use of RichText widget to create clickable text label. TextSpan widget is great choice for rendering more than just plain text. It's recognizer property can be used for responding to gestures more appropriately. In this case, I'll use TapGestureRecognizer as recognizer. TapGestureRecognizer helps to disambiguate gestures from other potential gestures. Clicking / tapping on link will open up the url in a WebView. In this example, it's a Google Doc with sample privacy policy text in it. Let's put all it together as code below:

Expanded(
  child: RichText(
      text: TextSpan(
          text: label,
          style: TextStyle(
              color: Colors.redAccent,
              decoration: TextDecoration.underline,
              fontSize: 20.0),
          //TapGestureRecognizer helps to disambiguate gestures from other potential gestures
          recognizer: TapGestureRecognizer()
            ..onTap = () {
              //open hyperlink in webview
              Navigator.pushNamed(context, WEBVIEW,
                  arguments:
                      WebViewArguments(title: label, url: hyperlink));
            })),
),

Next comes the Switch widget. It's fairly simple. Widget's value, onChanged attributes are assigned values from parent widget. selected boolean is assigned to value, and onChange() is assigned to onChanged attribute like below:

Switch(
  value: selected,
  onChanged: (bool v) {
    onChange(v);
  },
)

That's all to it. We're ready to move on to using this widget from another widget or page. Settings page is one example where this widget can be used in to create clickable label along with switch settings.

Using Custom Switch Widget

I've created a sample page SwitchListTile1 to demonstrate integrating our brand new custom widget HyperlinkedLabelSwitch. SwitchListTile1 page is a StatefulWidget. We chose it to be StatefulWidget because we want to update the value of toggle switch to reflect privacy policy acceptance status. As usual, we need a State for StatefulWidget, say _SwitchListTileState like below:

class SwitchListTile1 extends StatefulWidget {
  @override
  State<StatefulWidget> createState() {
    return _SwitchListTileState();
  }
}

class _SwitchListTileState extends State<SwitchListTile1> {
}

_SwitchListTileState has two parameters: 1. accepted: A boolean flag to keep track of state of privacy policy acceptance status. 2. privacyLabel: Text message shown to user. It's 'Privacy Policy' by default. It changes to 'Privacy Policy (Accepted)', when accepted is true.

The body of this sample page is simple, and consists of one Column widget. This Column has only one child HyperlinkedLabelSwitch widget. HyperlinkedLabelSwitch is initialized with default values for privacyLabel and accepted. The value of hyperlink remains constant and hence hard wired, since we don't accept the location of privacy policy to be changed frequently. setState(){} is called whenever value of switch changes. privacyLabel's value is updated to include (Accepted) when accepted is true.

body: Column(
  children: <Widget>[
    HyperlinkedLabelSwitch(
      padding:
          const EdgeInsets.symmetric(horizontal: 20.0, vertical: 50.0),
      label: privacyLabel,
      hyperlink:
          'https://docs.google.com/document/d/1TAqTE7MBzuIagISHHzjGxSHoY1z884LXR3iGIojz1sA/edit?usp=sharing',
      selected: accepted,
      onChange: (bool v) {
        setState(() {
          accepted = v;
          if (accepted) {
            privacyLabel = 'Privacy Policy (Accepted)';
          } else {
            privacyLabel = 'Privacy Policy';
          }
        });
      },
    )
  ],
)

and, we are done !

Next section has complete example code for easy reference.

Complete example code

This section has full example code for your reference. There are few dependencies like webview.dart, router.dart. They are meant to be included for app navigation purposes and showing privacy policy documents in a web view. Please refer to Github repo for access to full code.

import 'package:flutter/gestures.dart';
import 'package:flutter/material.dart';
import 'package:flutter_widgets/menus/webview.dart';
import 'package:flutter_widgets/router.dart';

class SwitchListTile1 extends StatefulWidget {
  @override
  State<StatefulWidget> createState() {
    return _SwitchListTileState();
  }
}

class _SwitchListTileState extends State<SwitchListTile1> {
  bool accepted = false;
  String privacyLabel = 'Privacy Policy';

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text("SwitchListTile: Clickable label"),
      ),
      body: Column(
        children: <Widget>[
          HyperlinkedLabelSwitch(
            padding:
                const EdgeInsets.symmetric(horizontal: 20.0, vertical: 50.0),
            label: privacyLabel,
            hyperlink:
                'https://docs.google.com/document/d/1TAqTE7MBzuIagISHHzjGxSHoY1z884LXR3iGIojz1sA/edit?usp=sharing',
            selected: accepted,
            onChange: (bool v) {
              setState(() {
                accepted = v;
                if (accepted) {
                  privacyLabel = 'Privacy Policy (Accepted)';
                } else {
                  privacyLabel = 'Privacy Policy';
                }
              });
            },
          )
        ],
      ),
    );
  }
}

class HyperlinkedLabelSwitch extends StatelessWidget {
  final String label;
  final String hyperlink;
  final bool selected;
  final Function onChange;
  final EdgeInsets padding;


  const HyperlinkedLabelSwitch(
      {Key key,
      this.label,
      this.selected,
      this.onChange,
      this.padding,
      this.hyperlink});

  @override
  Widget build(BuildContext context) {
    return Padding(
      padding: padding,
      child: Row(
        children: <Widget>[
          //1. First widget in row is for label
          //Expanded widget claims the empty area
          Expanded(
            child: RichText(
                text: TextSpan(
                    text: label,
                    style: TextStyle(
                        color: Colors.redAccent,
                        decoration: TextDecoration.underline,
                        fontSize: 20.0),
                    //TapGestureRecognizer helps to disambiguate gestures from other potential gestures
                    recognizer: TapGestureRecognizer()
                      ..onTap = () {
                        //open hyperlink in webview
                        Navigator.pushNamed(context, WEBVIEW,
                            arguments:
                                WebViewArguments(title: label, url: hyperlink));
                      })),
          ),

          //2. Next comes the switch to save the user's selection
          Switch(
            value: selected,
            onChanged: (bool v) {
              onChange(v);
            },
          )
        ],
      ),
    );
  }
}

Source code repo: Recipe source code is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Follow me at twitter

Flutter FactsBot using DialogFlow

2019-08-20T00:00:00-04:00

Background

In this article, we'll learn to integrate DialogFlow in a Flutter app for enriched conversational experience. I'll use the sample app that we built earlier in my previous article Designing Cross platform Flutter prototype for Landing Page (Web-Hummingbird, Android, iOS). We'll be integrating DialogFlow conversational API in native Flutter App.

You can refer to previous articles here:

Checkout the companion video:

Introduction

In this article, I'll show you how we can integrate DialogFlow in a Flutter app for enriched conversational experience. We'll keep it to a fun app for demonstration purposes. We'll add a chat icon on our landing page. Clicking on this chat icon, will take user to a chat like screen. Whenever user type sentence or word consisting "Flutter" in it, our "Flutter Facts Bot" will present user a fact about Flutter :) Simple !

To adapt our existing landing page app to this new conversational style, we'll be taking following steps:

Setting up DialogFlow
App's Integration with DialogFlow
Adding Chat like Icon at Landing Page
Developing "FlutterFactsDialogFlow" interface

Setting up DialogFlow

Create an account at DialogFlow. It's free to create account.

Create agent by clicking on "Create Agent" button as shown in image below:

Assign a google cloud project. Navigate to Google Cloud Console to create a new project, if you don't have a project yet. I'll choosing my existing google cloud project named - "flutter-to-fly".

Create/Choose Intent. I'll be using default welcome intent for this tutorial. This is the very first intent presented to user at the beginning of conversation.

Train intent. Add training phrases at this step. Training phrases will include words or sentence(s) which you think user could use to invoke conversation. I'm using word "flutter" in various combinations. As far as user has "flutter" keyword in their sentence, they'll be presented a fact about flutter. Click "Save" when you're done adding all possible keywords/phrases. It'll start agent training.

Add Responses. I'll be adding simple text responses for this tutorial. Response text is the output for the phrases tried out by user. If a match is found for user input text, one of the text response will be returned to user. In our case, as far as user says "flutter" in its query, a Flutter fact will be returned.

You can try out responses at the right panel either by typing or speaking out phrases in order to test the fulfillment.

DialogFlow agent is trained and ready to return text responses for default intent !

App's Integration with DialogFlow

Now, we want to integrate our newly trained DialogFlow intent into "Flutter Facts" feature of our app.

Head over to Google Cloud Console.
Choose Google Cloud project.
Select "API & Services"
Click on credentials.

Click on "Create credentials" drop down menu, and choose "Service account key" option.

Select "DialogFlow integrations" option in Service account drop-down. Choose recommended "JSON" format for key type.

Download you private key to your machine. Keep this safe somewhere private to you. DO NOT commit this key into version control system.

Note: Save your credentials file at a safe location. DO NOT check-in this file in version control system like Github, BitBucket etc.

Copy credentials file flutter-to-fly-creds.json in to assets directory. I prefer to make symlink for this file inside assets folder to save me from accidentally checking it in Github.

pubspec.yaml dependencies for DialogFlow plug-in:

dependencies:
  flutter_dialogflow: ^0.1.2

At this point your Flutter app is ready to send requests to DialogFlow APIs.

Adding Chat like Icon at Landing Page

Let's add a chat like icon to invoke conversation with DialogFlow. Clicking on this chat icon will open a new page with an input box for user to enter their query. For every query entered by user will fetch a flutter fact from DialogFlow.

In this section, I'll be adding a chat icon in the bottomRight corner of the landing page like below:

I'll be creating a file say widgets_lib.dart to keep track of my all reusable widgets. The widget factBot is a FloatingActionButton to initiate FlutterFacts user interface. You would notice that onPressed: property sends a message to router to open FlutterFacts UI. FACTS_DIALOGFLOW string is like a key-value mapping between page identifier and target page that should launch as result.

Widget factBot(BuildContext context) {
  return Container(
    alignment: Alignment.bottomRight,
      child: FloatingActionButton(
        materialTapTargetSize: MaterialTapTargetSize.padded,
        child: Center(
          child: Icon(Icons.chat),
        ),
        elevation: 4.0,
        backgroundColor: MyColors.blue1,
        onPressed: () => Navigator.pushNamed(context, FACTS_DIALOGFLOW),
      )
  );
}

Navigating in the app:

I'll be using page routing for navigating from one page to another in this Flutter app. Let's quickly review router.dart. This file defines a string to represent each page, and make use of RouteSettings attribute to open a qualifying target page. When routeSettings.name matches FACTS_DIALOGFLOW value, FlutterFactsDialogFlow() page will open.

const String FACTS_DIALOGFLOW = "FACTS_DIALOGFLOW";

Route<dynamic> generateRoute(RouteSettings routeSettings) {
  switch(routeSettings.name) {
    case '/':
      return MaterialPageRoute(builder: (context) => MyHomePage());
      break;
    case FACTS_DIALOGFLOW:
      return MaterialPageRoute(builder: (context) => FlutterFactsDialogFlow());

  }
}

Let's see what changes we need to make in main.dart to support this routing based navigation strategy:

import 'router.dart' as router;

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      ...
      onGenerateRoute: router.generateRoute,
      initialRoute: '/',
    );
  }
}

You'll notice that I imported router.dart as first thing, and then set onGenerateRoute property of MaterialApp to re-route to given page. Don't forget to provide initialRoute attribute. This attribute dictates which page will be opened as first thing after app launch.

User and FlutterFacts bot interaction is implemented in FlutterFactsDialogFlow() class. Let's checkout the details in next section.

Developing "FlutterFactsDialogFlow" interface

In this section, I'll be building a simple chat window looking interface to interact with 'FlutterFactsBot'. Interface will have following components in addition to AppBar:

User input box at the bottom
Top part to show interaction log between user and 'FlutterFactsBot'
User and 'FlutterFactsBot' icons

FlutterFactsBot in Action !*

This is how user and FlutterFactsBot interaction log would like:

Let's dive in coding the interface now!

Show me the code:

When user clicks on the chat icon, it'll launch FlutterFactsDialogFlow page, which is StatefulWidget. This widget will have a list of fact messages _messages to display the interaction log of conversation between user and FlutterFactsBot. This list will be displayed in reverse order, that means most recent messages will be at the bottom.

Page has two parts: appBar & body. AppBar has title for the page whereas body part has three widgets inside a Column widget. Flexible widget contains a ListView to show _messages list in reverse order. Divider widget is used to give a visual separation between interaction log and text box _queryInputWidget to input user's query.

class FlutterFactsDialogFlow extends StatefulWidget {
  FlutterFactsDialogFlow({Key key, this.title}) : super(key: key);

  final String title;

  @override
  _FlutterFactsDialogFlowState createState() => new _FlutterFactsDialogFlowState();
}

class _FlutterFactsDialogFlowState extends State<FlutterFactsDialogFlow> {
  final List<FactsMessage> _messages = <FactsMessage>[];

  ...

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        centerTitle: true,
        title: Text("Flutter Facts"),
      ),
      body: Column(children: <Widget>[
        Flexible(
            child: ListView.builder(
              padding: EdgeInsets.all(8.0),
              reverse: true, //To keep the latest messages at the bottom
              itemBuilder: (_, int index) => _messages[index],
              itemCount: _messages.length,
            )),
        Divider(height: 1.0),
        Container(
          decoration: new BoxDecoration(color: Theme.of(context).cardColor),
          child: _queryInputWidget(context),
        ),
      ]),
    );
  }  
}

Let's explore _queryInputWidget widget for entering user's query text. This is the area where user can enter their query text. It has two parts to it: TextField widget to enter query text, and IconButton for submitting query. TextField widget needs a controller and onSubmitted attributes. onSubmitted attribute calls the given method _submitQuery in our case, once user is done entering the text and hits enter. IconButton widget is another way to submit text to DialogFlow. It's onPressed calls _submitQuery as well.

class _FlutterFactsDialogFlowState extends State<FlutterFactsDialogFlow> {
  final TextEditingController _textController = new TextEditingController();

  Widget _queryInputWidget(BuildContext context) {
    return Container(
      child: Container(
        margin: EdgeInsets.symmetric(horizontal: 8.0, vertical: 8.0),
        child: Row(
          children: <Widget>[
            Flexible(
              child: TextField(
                controller: _textController,
                onSubmitted: _submitQuery,
                decoration: InputDecoration.collapsed(hintText: "Send a message"),
              ),
            ),
            Container(
              margin: EdgeInsets.symmetric(horizontal: 4.0),
              child: IconButton(
                  icon: Icon(Icons.send),
                  onPressed: () => _submitQuery(_textController.text)),
            ),
          ],
        ),
      ),
    );
  }

...

}

Let's take a look what _submitQuery does when user is done entering their query about Flutter. As you see in code below, when _submitQuery is called, first thing it does is to clear the input TextField to make it ready for the next user interaction. It takes the TextField text and creates a data structure FactsMessage to display interaction log. You might notice few things here. _submitQuery takes input as text. When _submitQuery is called from TextField widget, text is being passed to this method implicitly. Whereas when _submitQuery is called from IconButton's onPressed method text is retrieved from _textController and passed into _submitQuery method.

void _submitQuery(String text) {
  _textController.clear();
  FactsMessage message = new FactsMessage(
    text: text,
    name: "Priyanka",
    type: true,
  );
  setState(() {
    _messages.insert(0, message);
  });
  _dialogFlowResponse(text);
}

FactsMessage's name property is Priyanka to represent the user (in this case, I have hard coded my name as user for demonstration purposes) who is interacting with Bot. You'll see this name property will change to Flutter Bot when FlutterMessage is being constructed in _dialogFlowResponse. FactsMessage's data structure uses name property to show who owns the message. FactsMessage is a StatelessWidget to display interaction message between user and so called 'FlutterFactsBot'.

It takes three parameters:

text: query / response Text
name: who the text belongs to
type: boolean. true for user. false means bot.

type parameter decides which message format to be rendered from userMessage or botMessage.

class FactsMessage extends StatelessWidget {
  FactsMessage({this.text, this.name, this.type});

  final String text;
  final String name;
  final bool type;

  ...

  @override
  Widget build(BuildContext context) {
    return new Container(
      margin: const EdgeInsets.symmetric(vertical: 10.0),
      child: new Row(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: this.type ? userMessage(context) : botMessage(context),
      ),
    );
  }  

}

FactsMessage widget has two types of messages: userMessage and botMessage. They differ in alignment of the widgets within a message row.

In screenshot below, userMessage is highlighted in red, and botMessage is highlighted in green.

Let's checkout userMessage widget's code below. It's List of widgets aligned to end of the screen. All user's messages will appear towards the left side of the screen, ending into CircleAvatar.

List<Widget> userMessage(context) {
  return <Widget>[
    Expanded(
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.end,
        children: <Widget>[
          Text(this.name, style: Theme.of(context).textTheme.subhead),
          Container(
            margin: const EdgeInsets.only(top: 5.0),
            child: Text(text),
          ),
        ],
      ),
    ),
    Container(
      margin: const EdgeInsets.only(left: 16.0),
      child: CircleAvatar(child: new Text(this.name[0])),
    ),
  ];
}

FlutterFactsBot's messages will appear towards the right side of the screen, starting with the CircleAvatar

List<Widget> botMessage(context) {
  return <Widget>[
    Container(
      margin: const EdgeInsets.only(right: 16.0),
      child: CircleAvatar(child: Text('Bot')),
    ),
    Expanded(
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: <Widget>[
          Text(this.name,
              style: TextStyle(fontWeight: FontWeight.bold)),
          Container(
            margin: const EdgeInsets.only(top: 5.0),
            child: Text(text),
          ),
        ],
      ),
    ),
  ];
}

Let's move on to the last piece of the puzzle: getting response from DialogFlow API and rendering it.

DialogFlow Response: After submitting query and rendering user's message in interactionLog, query is submitted to DialogFlow and response is rendered right below the companion userMessage. This is how query is submitted to DialogFlow API using flutter_dialogflow plug-in:

void _dialogFlowResponse(query) async {
  _textController.clear();
  AuthGoogle authGoogle =
  await AuthGoogle(fileJson: "assets/flutter-to-fly-creds.json").build();
  Dialogflow dialogFlow =
  Dialogflow(authGoogle: authGoogle, language: Language.english);
  AIResponse response = await dialogFlow.detectIntent(query);
  FactsMessage message = FactsMessage(
    text: response.getMessage() ??
         CardDialogflow(response.getListMessage()[0]).title,
    name: "Flutter Bot",
    type: false,
  );
  setState(() {
    _messages.insert(0, message);
  });
}

FactsMessage is constructed and added to _messages conversation log. Every time user enters a query text consisting of word 'flutter', pre-canned text responses will be returned from DialogFlow. In this example, I've used very simple default text responses at DialogFlow for fulfillment. However, you can serve more dynamic content using Webhooks fulfillment.

You're Done :)

Keep Fluttering !

Source code

Source code is available here

[Update] Code has been tested on Flutter stable channel 1.12.13+hotfix.8, and Dart version Dart 2.7.0

[Update #2 - 04/20/20]

In case you're running into null response from DialogFlow, you may want to make sure that you've correct setup.

You can also try to create new credentials in google cloud with role as : Dialogflow ->Dialogflow api admin

References/Credits:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Using ColorTween in Flutter app

2019-08-07T00:00:00-04:00

Target Audience: Beginner

Recipe: Implement animation using ColorTween for Android, iOS and WebApp.

Focus Widget: ColorTween

Goal: Animating from one color to another for a quiz card's background based on the correct answer. We'll implement a card with picture of an animal in it, along with two choices to select from: 'Carnivorous' or 'Herbivorous'. When correct option is picked, background color of card will transition from grey to blue color in order to indicate correct selection otherwise background stays grey or turns grey from blue.

Checkout the companion video tutorial:

ColorTween for Native platforms (Android & iOS)

Step #1. Data (items.dart) I'll be creating a little data structure CardItem to keep track of model for UI card. It has four parts to represent a Quiz card: title, description, image and animalType. title and description are not used to render on Card UI. image has path to image in assets directory in Android Studio.

class CardItem {
  final String title;
  final String description;
  final String image;
  final String animalType;

  CardItem(this.title, this.description, this.image, this.animalType);

  CardItem.fromMap(Map<String, dynamic> data)
      : title = data["title"],
        description = data["description"],
        image = data["image"],
        animalType = data['animalType'];

  static List<CardItem> fromData(List<dynamic> data) {
    return data.map((item) => CardItem.fromMap(item)).toList();
  }
}

In the class above, you might have noticed fromMap(...) and fromData(...) methods, which are used to parse json data (intended to be fetched over network). In this recipe, I've hard-wired the sample json data as below:

[  
   {  
      "title":"cat",
      "description":"Cat is carnivorous animal.",
      "image":"assets/images/carnivorous_cat.jpg",
      "animalType":"carnivorous"
   },
   {
     ...
   },
   ...
]

Parsing json string above is done as below:

final List<CardItem> cardItems =
    CardItem.fromData(json.decode(Samples.jsonData()));

Now, importing items.dart in any class/file, will give access to cardItems. An item in list can be accessed as cardItems[0], cardItems[1] and so on.

Step #2. User Interface (color_tween.dart) We'll be implementing following quiz like card to demonstrate transitioning from grey color to blue and vice versa.

UI's body has main three parts:

Positioned Widget: To display card.
Image: image of the animal to quiz on.
Row of FlatButton widgets: Two FlatButton to present choice of Carnivorous in red and Herbivorous in green color.

Step #2-a. Quiz Card UI anatomy:

@override
Widget build(BuildContext context) {
  //we need screenSize to render card relative to the given device's screen size
  Size screenSize = MediaQuery.of(context).size;

  //Fetching image from `assets` folder
  DecorationImage decorationImage = DecorationImage(
      image: AssetImage(cardItems[0].image), fit: BoxFit.fitWidth);

  return Scaffold(
    appBar: AppBar(...),
    body: Container(
      ...

      Positioned(
        child: Card(
          ...
          //parent container to host the quiz card
          child: Container(
            alignment: Alignment.center,
            width: screenSize.width / 1.2,
            height: screenSize.height / 1.7,
            ...,

            //Contents of card: Image and FlatButtons for quiz options
            child: Column(
              children: <Widget>[

                //Image of quiz animal
                Container(
                  //Note: width of image is same as parent
                  width: screenSize.width / 1.2,

                  //Note: Image's height is smaller than parent, so that parent can contain image inside it.
                  height: screenSize.height / 2.2,

                  //Rendering image
                  decoration: BoxDecoration(
                      borderRadius: BorderRadius.only(
                        topLeft: Radius.circular(8.0),
                        topRight: Radius.circular(8.0),
                      ),
                      image: decorationImage),
                ),
                //Widget to contain FlatButtons for quiz options
                Container(
                  //Width remains same as of parent, however height needs to be calculated to position in under image.
                  width: screenSize.width / 1.2,
                  height:
                      screenSize.height / 1.7 - screenSize.height / 2.2,

                  child: Row(
                    ...
                    children: <Widget>[
                      FlatButton(
                        ..
                        //Animation trigger: This is where animation will be triggered
                        onPressed: () => {},
                        child: Container(
                          ..
                          child: Text("Carnivorous"),
                        ),
                      ),
                      FlatButton(
                        ..
                        //Animation trigger: This is where animation will be triggered
                        onPressed: () => {},
                        child: Container(
                          ..
                          child: Text("Herbivorous"),
                        ),
                      ),
                    ],
                  ),
                )
              ],
            ),
          ),
        ),

      ),
    ),
  );
}

Step #3: Implementing ColorTween Animation

Finally, time to implement transition animation from grey to blue color using ColorTween class. There are couple of steps that we would need to achieve that.

Using SingleTickerProviderStateMixin with Stateful parent's State:

class ColorTweenAnimationDemo extends StatefulWidget {
  @override
  _ColorTweenAnimationDemoState createState() =>
      new _ColorTweenAnimationDemoState();
}

class _ColorTweenAnimationDemoState extends State<ColorTweenAnimationDemo>
    with SingleTickerProviderStateMixin {
      ...
}

Initializing AnimationController and Animation inside initState(). AnimationController is intended to control the state of the animation like starting using forward(), revering using reverse() and stopping. Animation<Color> will be used to define value change between one color to another, which is from grey to blue in our case. ColorTween class is exactly what it says between colors. It begins with beginning color 'grey' and ends with blue. This transition behavior is attached with AnimationController _controller to manage the animation. A listener can be added to listen to state changes from where it starts until it stops.

...

AnimationController _controller;
Animation<Color> animation;

@override
void initState() {
  super.initState();

  _controller = AnimationController(
    duration: const Duration(milliseconds: 2000),
    vsync: this,
  );

  animation = ColorTween(
    begin: Colors.grey,
    end: Colors.blue,
  ).animate(_controller)
    ..addListener(() {
      setState(() {});
    });
}

Animating Card's background: Add animation.value as color attribute for BoxDecoration(...) in parent's card widget like below:

...
//parent container to host the quiz card
child: Container(
                  ...
                  width: screenSize.width / 1.2,
                  height: screenSize.height / 1.7,
                  decoration: BoxDecoration(
                    color: animation.value,
                    borderRadius: BorderRadius.circular(8.0),
                  ),
                  ...
                )
...

Triggering animation: We want our color change animation starts when we click the right answer which is Carnivorous in out case. When we press FlatButton at left, background color changes from grey to blue. When FlatButton at right, Herbivorous is clicked, reverse() animation is called, which changes color from blue to back to grey. Let's see how animation is started from FlatButton's onPressed() methods:

children: <Widget>[
  FlatButton(
    ..
    //Animation trigger: This is where animation will be triggered, responsible to change color from grey to blue.
    onPressed: () => {_controller.forward()},
    child: Container(
      ..
      child: Text("Carnivorous"),
    ),
  ),
  FlatButton(
    ..
    //Animation trigger: This is where the reverse animation will be triggered, responsible to change color back to grey.
    onPressed: () => {_controller.reverse()},
    child: Container(
      ..
      child: Text("Herbivorous"),
    ),
  ),
],

Disposing AnimationController: Don't forget to dispose AnimationController.

@override
dispose() {
  _controller?.dispose();
  super.dispose();
}

What about Flutter Web ?

[UPDATE Sept 23rd, 2019] Since release of Flutter 1.9, there's no need of maintaining separate code bases for native and web Flutter implementations. Please refer to my article about migrating to Flutter 1.9 for details.

Note: As of today Aug 7th, 2019- There's an issue in running Flutter Web App after upgrading to the latest version of Flutter SDK.

Let's achieve the same animations on Web platform. Please refer to my this article, if you're new to Flutter-Web / Hummingbird and need help with setting up web project. In short, we would need to create an another branch say animations-web to host all web related code since web libraries are not pushed to same repository as of native platform. You'll need to fetch libraries directly from their Github repo.

It means imports in native vs web platform are different. Make sure that all files have correct web intended imports.

Native:
import 'package:flutter/material.dart';

Web:
import 'package:flutter_web/material.dart';

pubspec.yaml: I keep a backup for native and web pubspec.yaml config as pubspec.yaml.web and pubspec.yaml.native in both branches. Copy correct file's content into current pubspec.yaml.
Building project in web branch animations-web. Make sure that you're in stable channel:

flutter channel stable

flutter clean

flutter pub upgrade

flutter pub get

flutter packages pub global run webdev serve

Note: You may notice that image doesn't render using AssetImage. I use Image.network() to render images in web version like below:

Container(
  width: screenSize.width / 1.2,
  height: screenSize.height / 2.2,
  child: Image.network(cardItems[0].image),
),

Here's screenshot of the web version:

Source code repo:

[UPDATE] Native and Web codebases are merged into one codebase since release of Flutter 1.9.

Source code is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Follow me at twitter

Understanding Flutter PopupMenuButton Widget

2019-07-19T00:00:00-04:00

Target Audience: Beginner

Recipe: Implementing "Settings" menu using PopupMenuButton widget in Stateless vs Stateful manner.

Focus Widget: PopupMenuButton Widget

Goal:

Understanding the difference between Stateful vs Stateless PopupMenuButton widget implementations.
"Settings" menu using PopupMenuButton to display four menu items : 'Home', 'Github', 'Videos' and 'Jobs'.

PopupMenuButton (Stateless) workflow:

PopupMenuButton (Stateful) workflow:

Checkout the companion video tutorial:

In this recipe, I'll show you how to use PopupMenuButton widget as Stateless and Stateful widgets, and when to use one over another.

As we know that Stateless widgets are passed in to values/properties when they're initiated, and don't change thereafter. They are immutable and can't change their properties dynamically. For example, when a screen or page is created as a Stateless widget, it can't update properties or state of its children widgets.

For instance, when you're implementing a counter, and expect a button to update the number of times it's tapped on page's body (Text) widget, you may want to use Stateful widget rather a Stateless widget.

A good example of Stateless widget is RaisedButton. Certain properties are passed into RaisedButton when initializing, which remains unchanged during the lifecycle of the widget like color, size etc.

For demonstration purposes, I'll create two pages with Settings menu in AppBar. This Settings menu will have few pre-defined menu-items.

First page inherits Stateless widget. Selecting different options from Settings menu, would happily print value on the console, but wouldn't update any other widget on that given page. However, we can navigate to another page when a selection is made.

Second page inherits Stateful widget. Choosing an option from Settings menu will update the selection in body's Text widget of the same screen.

Let's go ahead and implement four menu items ('Home', 'Github', 'Videos' and 'Jobs') for "Settings" menu. In case you're not aware what Settings menu is referred in the Material design world: it's the three vertical dots in top-right corner of 'AppBar'. This page is simple.

It has three main widgets:

AppBar: AppBar contains Settings vertical dotted icon.
PopupMenuButton: Settings menu uses this widget to list all options.
Body: Current choice is updated in body part in Text widget.

Expected behavior is that whenever a choice is selected in Settings menu, it gets printed page's body area. If "Github" option is selected, then "Github" should be printed in body. We'll also print this chosen selection on console/terminal to make sure that control is coming at the right place.

PopupMenuButton (Stateless)

Choosing an option from Settings menu will open the selected link in WebView.

Choosing "Github" option from menu:

Github link opened in WebView:

This is how page for Stateless variation of PopupMenuButton would look like:

Widget build(BuildContext context) {
  return Scaffold(
    appBar: AppBar(
      title: Text('PopupMenuButton (Stateless)'),
      actions: <Widget>[
        PopupMenuButton(
          onSelected: (value) {
            //print the selected option
            print(value);

            //Update the current choice.
            //However, this choice won't be updated in body section since it's a Stateless widget.
            choice = value.toString();
          },
          itemBuilder: (BuildContext context) {
            return NavLinks.values.map((link) {
              return PopupMenuItem(
                value: link,
                child: Text(displayString(link)),
              );
            }).toList();
          },
        ),
      ],
    ),
    body: Center(
      child: Text(
        //Print the current choice
        choice,
        style: TextStyle(fontSize: 30),
      ),
    ),
  );
}

As I've mentioned above, choosing an option can be acknowledged that an option has been picked by printing current selection on console with help of print(value). In this case body's default text doesn't change. However, current selection is printed on terminal correctly. Basically, this(Stateless) type of widget is not capable of handling state of the widget and does justice to its name being Stateless :)

To make better sense for menu item selection. Let's open those links in a WebView.

onSelected: (value) {
            //print the selected option
            print(value);

            //Update the current choice.
            //However, this choice won't be updated in body section since it's a Stateless widget.
            choice = displayString(value);

            Navigator.pushNamed(context, WEBVIEW,
                arguments: WebViewArguments(
                    title: displayString(value), url: linkUrl(value)));
          }

WEBVIEW tells system how to find WebView page. Checkout the router.dart to get better understanding of navigation and routing.

Note: To open WebView for iOS, you would need to add key io.flutter.embedded_views_preview and value YES in Info.plist.

Now, let's move on to observe Stateful widget's behavior.

PopupMenuButton (Stateful)

Choosing an option from Settings menu will update the Text widget in body of the page.

Choosing "Github" option from menu:

Displaying selected option Text widget:

This is how page for Stateful variation of PopupMenuButton would look like:

class PopupMenuButtonWidgetStateFul extends StatefulWidget {
  @override
  State<StatefulWidget> createState() => _PopupMenuButtonWidgetState();
}

class _PopupMenuButtonWidgetState extends State {
  String choice = "Click Settings to make your selection";

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('PopupMenuButton (Stateful)'),
        actions: <Widget>[
          PopupMenuButton(
            onSelected: (NavLinks value) {
              setState(() {
                //print the selected option
                print(value);

                //Update the current choice.
                choice = displayString(value);
              });
            },
            itemBuilder: (BuildContext context) {
              return NavLinks.values.map((link) {
                return PopupMenuItem(
                  value: link,
                  child: Text(displayString(link)),
                );
              }).toList();
            },
          ),
        ],
      ),
      body: Center(
        child: Text(choice, style: TextStyle(fontSize: 30),),
      ),
    );
  }
}

Notice the setState() method. All Stateful widgets implement createState() and define a state of the widget that it could be in at a given point of time. A child widget doesn't get updated unless it's being updated inside setState(). You may notice that I'm updating the current selection in setState() method as well.

Note: displayString(NavLinks link) and String linkUrl(NavLinks link) are convenience methods.

Conclusion

In nutshell, you may want to use Stateful widgets when you want parts of the screen or children widgets to update their values/properties. Stateless widgets are immutable. They can be used in cases where properties of widgets don't need to be updated frequently, and/or to implement page navigation as we did in above example for navigating to WebView pages for chosen menu item url.

Source code repo:

Native Apps (Android / iOS) recipe source code is available here
Web Apps (Hummingbird) recipe source code is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Follow me at twitter

How to fix Material Icons for Flutter Web (Hummingbird)

2019-07-18T00:00:00-04:00

Target Audience: Beginner

Recipe: Material Icons for Flutter Web (Hummingbird).

Focus Widget: Material Icons

Goal: Fix MaterialIcon rendering for Flutter WebApps.

Checkout the companion video tutorial:

[Before] Default Material Icons rendering in Flutter WebApp:

[After] Fixed Material Icons rendering for Flutter WebApp:

Lets's go!

Step #1. `pubspec.yaml`

Add material icon dependency in pubspec.yaml:

flutter:
  uses-material-design: true

Step #2. Download Material Icons font

Download MaterialIcons fonts from here. Copy MaterialIcons-Regular.ttf file under web/assets/fonts directory.

Step #3. `FontManifest.json`

Add FontManifest.json in web/assets directory.

[
  {
    "fonts": [
      {
        "asset": "fonts/MaterialIcons-Regular.ttf"
      }
    ],
    "family": "MaterialIcons"
  }
]

Note: I've removed debug banner to be able to show Settings vertical dots. All you need to do is to set debugShowCheckedModeBanner flag to false in MaterialApp like below:

return new MaterialApp(
      debugShowCheckedModeBanner: false,
      ...
    );

Source code repo: Source code is here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Follow me at twitter

Using Flutter Themes for Cross-platform Landing Page (Web-Hummingbird, Android, iOS)

2019-06-27T00:00:00-04:00

Background

This article is in continuation of Making Cross-platform Flutter Landing Page Responsive. In previous post, we learned how to make a cross-platform (Web, Android and iOS) landing page responsive for various form-factors. In this post, we'll see how can we change look and feel or theme of the landing page quickly, just by modifying small piece of code.

Checkout the companion video:

Part-1. (Themes Introduction):

Part-1a. (Global Theme):

Part-2. (Local Theme):

Part-3. (Custom Fonts-Web):

Part-3a. (Custom Fonts-Native Demo):

Goal: Our goal is to create themes for Cross-platform Flutter landing page (Web and Native apps).

Theme#1: BlueTheme Uses custom font Indie Flower and blue color for header section. "Subscribe" button demonstrates local widget theming.

Theme#2: PurpleTheme Uses purple color for header section. No default font or text styling specified. "Subscribe" button demonstrates local widget theming.

Theme#3: GreenTheme Uses green color for header section. No default font specified. Header navigational links are styled italic. "Subscribe" button demonstrates local widget theming.

Introduction

This article is third in Designing Cross platform Flutter prototype for Landing Page series. In this article, I'll show you how to create and use Flutter Themes for landing page.

Two ways to implement Themes in Flutter:

Global Theme: This type of theme affects whole app. Global themes are implemented using ThemeData
Local Themes: This is responsible for making changes to one part of the app rather touching any other part of the app. Local themes are implemented using Theme widget and passing specific ThemeData instance to it.

Let's get started by defining global theme say AppThemeBlue for our landing page. Later on, I'll show you how a particular widget's (say SubscribeButton) theming could be changed using Theme widget.

This article covers three aspects of Flutter Themes:

Part #1: How to create and use Global App themes
Part #2: How to create and use local themes for a widget
Part #3: How to use Custom Fonts in themes

Part #1: How to create and use Global App themes

I've created a utility class MyAppThemes to keep track of my all themes related configurations. All methods in this class are static. I'll be using three theme colors: Blue (default), Green and Purple to demonstrate different themes. I've created another utility class MyColors to keep all colors in one place. This gives me flexibility to change shades of any particular color to a desired one at one place rather hunting for each and every occurrence in whole code base.

Defining App's global theme: We need to customize ThemeData's attributes to achieve our desired appearance of the app. I've used different hues of blue for primaryColor, secondaryHeaderColor and accentColor. I'll be referring to one or another of these colors from my app's widgets later from the code base. Note: I'm using pre-defined colors in MyColors class that I've named as color name prefixed with a number like blue1, blue2 and so on for all colors that I've used in my web/native app.

This is how a basic theme in blue would look like (all colors are used as different shades of blue). Note: In this article, I'll be implementing lighter theme only. You can read more about brightness attribute here.

static ThemeData AppThemeBlue(BuildContext context) {
  return ThemeData(
    brightness: Brightness.light,
    primaryColor: MyColors.blue1,
    secondaryHeaderColor: MyColors.blue2,
    accentColor: MyColors.blue3,  

  );
}

Let's define Green and Purple themes like below. All we've to do is to pick our favorite hues of those colors for primaryColor, secondaryHeaderColor and accentColor attributes.

Green theme implementation:

static ThemeData AppThemeGreen(BuildContext context) {
   return ThemeData(
     // Define the default brightness and colors for the overall app.
     brightness: Brightness.light,
     primaryColor: MyColors.green1,
     secondaryHeaderColor: MyColors.green2,
     accentColor: MyColors.green3,
   );
 }

Purple theme implementation:

static ThemeData AppThemePurple(BuildContext context) {
  return ThemeData(
    // Define the default brightness and colors for the overall app.
    brightness: Brightness.light,
    primaryColor: MyColors.purple1,
    secondaryHeaderColor: MyColors.purple2,
    accentColor: MyColors.purple3,
  );
}

TextThemes: Let's define default text theme as below. We'll use this textTheme for our Blue and Purple themes.

// Define the default TextTheme for headline, title and body text
static TextTheme getDefaultTextTheme(BuildContext context) {
  return TextTheme(
    headline: TextStyle(fontSize: 36.0, fontWeight: FontWeight.bold),
    title: TextStyle(
        fontSize: 20.0,
        fontStyle: FontStyle.normal,
        fontWeight: FontWeight.bold),
    body1: TextStyle(
        fontSize: 26.0,
        fontStyle: FontStyle.italic,
        fontWeight: FontWeight.normal),
  );
}

Extending parent themes: Extending parent themes means to be able to change few attributes of parent theme, while keep other attributes same. In this example, we'll update textTheme. Our GreenTheme will make use of this example. Say, we want to make our title text as italic. Notice the italic text in header section in images above.

//Example of extending the parent theme. Overwrites textTheme with given attributes
static TextTheme getItalicTitleTextTheme(BuildContext context) {
  return Theme.of(context).textTheme.copyWith(
        title: TextStyle(
            fontSize: 20.0,
            fontStyle: FontStyle.italic,
            fontWeight: FontWeight.bold),
      );
}

Integrating TextTheme in ThemeData: Blue and Purple themes will use default textTheme:

static ThemeData AppThemeBlue(BuildContext context) {
  return ThemeData(
    ...
    textTheme: getDefaultTextTheme(context),
  );
}

static ThemeData AppThemePurple(BuildContext context) {
  return ThemeData(
    ...
    textTheme: getDefaultTextTheme(context),
  );
}

Green theme will use extended textTheme getItalicTitleTextTheme():

static ThemeData AppThemeGreen(BuildContext context) {
  return ThemeData(
    ...
    textTheme: getItalicTitleTextTheme(context),
  );
}

Using Custom themes in main.dart:

You can customize theme by changing theme attribute of MaterialApp as show below:

//entrance into app
void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      ...

      //This is where you can call a new theme !
      theme: MyAppThemes.AppThemeGreen(context),

      ...
    );
  }
}

You'll notice same textTheme for Blue and Purple theme. For GreenTheme, you'll see italic navigational links in the header section. Below are the screen shots for all themes at this stage. Note that all buttons are themed similarly as per their main theme color.

Theme #1 BlueTheme: Using blue color for all buttons.

Theme #2 PurpleTheme: Using purple color for all buttons.

Theme #3 GreenTheme: Using green color for all buttons. Header navigational links are styled italic.

Part #2: How to create and use local themes for a widget

Now, we want a particular button say "Subscribe" hued in orange theme. How would we do that ? This is where local themes come handy. Let's see how can we define a local theme. In EmailBox class, subscribe button is added as below:

...

Expanded(
  flex: 2,
  child: SubscribeButton(),
)

...

We can use Theme widget to wrap SubscribeButton() widget. Pass local theme ThemeData as data attribute of Theme widget, and add SubscribeButton() widget as child. In local ThemeData, you can overwrite primaryColor, secondaryHeaderColor and accentColor. I'm using orange hues in this example. The benefit of this approach is to keep widgets theme agnostic. For example, branding logo is something that you may want to keep as is, even if you may want to change look and feel of all your app.

Expanded(
    flex: 2,
    child:
        //Example of applying local themes to a certain widget in app
        Theme(
      data: ThemeData(
        primaryColor: MyColors.orange1,
        secondaryHeaderColor: MyColors.orange2,
        accentColor: MyColors.orange3,
      ),
      child: SubscribeButton(),
    ))

This is how SubscribeButton would look like for all themes:

Part #3: How to use Custom Fonts in themes

Let's move on to be able to use custom fonts in your landing page. First, you may want to download (or get it from your designer) custom font of your choice from your favorite platform. I'm using Google fonts website to download custom font for this example. I want to use Indie Flower Font for my BlueTheme only. Configuring custom fonts in Flutter Web is slightly different than Flutter Native apps.

Custom fonts for Web :

Let's explore Flutter Web first:

I've downloaded IndieFlower.ttf from Google Fonts Website.
Copy IndieFlower.ttf file into web/assets directory.
Create FontManifest.json file inside web/assets directory with following contents:

[
    {
        "family": "Indie Flower",
        "fonts": [
            {
                "asset": "IndieFlower.ttf"
            }
        ]
    }

]

Update BlueTheme to include fontFamily as 'Indie Flower':

static ThemeData AppThemeBlue(BuildContext context) {
  return ThemeData(
    ...

    // I used custom font for the default font family.
    fontFamily: 'Indie Flower',

    ...
  );

That's pretty much to it ! Here's screen shot of the web version:

Custom fonts on Native (Android, iOS) :

Let's make custom fonts work for native landing page. We would need to make two changes:

Don't forget to update native version of flutter dependencies as described in my another article about running flutter landing page cross-platform on web and native.
Copy over fonts file 'IndieFlower.ttf' inside fonts directory as fonts/IndieFlower.ttf directory.
Update fonts related configuration in pubspec.yaml:

fonts:
  - family: Indie Flower
    fonts:
      - asset: fonts/IndieFlower.ttf

Screenshot of final landing page at Android platform:

Screenshot of final landing page at iOS platform:

Keep Fluttering !

Source code repo:

References/Credits:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Making Cross-platform Flutter Landing Page Responsive (Web-Hummingbird, Android, iOS)

2019-06-11T00:00:00-04:00

Goal: Our goal is to make Flutter page responsive for Web and Native apps.

Web landing page:

Native landing screen:

Introduction

This post is continuation of Designing Cross platform Flutter prototype for Landing Page. In this article, I'll show you how to make landing page responsive (meaning adapting to given screen size).

Checkout the companion videos:

Part-1:

Part-2:

In previous post, we learned how to design and implement a cross-platform (Web, Android and iOS). It looked great on large screen like desktop/laptop. However, it's widgets overflown when web landing page was resized to smaller screen like below:

On native environment for a phone screen, it looked like this:

In this post, I'll be showing how to :

Implement a StatelessWidget ResponsiveWidget to support dynamic screen sizes.
Adapt landing page's body to large vs smaller screens.
Adapt landing page's header to show menu icon at smaller screens.

ResponsiveWidget utility class

Let's implement a StatelessWidget ResponsiveWidget that uses LayoutBuilder. LayoutBuilder is a widget which builds a widget tree that can depend on the parent widget's size. This class is responsible for detecting the screen size, and put them in one of the three buckets: Large, Medium and Small. It has utility static functions/methods to check the screen sizes.

I'll be using MediaQuery to access the size of the screen. This is how I'll be checking the size of the screens by using width of the screen in pixels.

class ResponsiveWidget {
  ...
  //Large screen is any screen whose width is more than 1200 pixels
  static bool isLargeScreen(BuildContext context) {
    return MediaQuery.of(context).size.width > 1200;
  }

  //Small screen is any screen whose width is less than 800 pixels
  static bool isSmallScreen(BuildContext context) {
    return MediaQuery.of(context).size.width < 800;
  }

  //Medium screen is any screen whose width is less than 1200 pixels,
  //and more than 800 pixels
  static bool isMediumScreen(BuildContext context) {
    return MediaQuery.of(context).size.width > 800 &&
    MediaQuery.of(context).size.width < 1200;
  }  
}

In the following section, I'll be building body of the landing page. In my previous post, I had only one design for landing page's body which is targeted to desktop size screens or say larger screens with width more than 1200 pixels. The widgets will give overflow signal when screen size is resized to smaller screen. To solve this problem, ideally you can design separate three designs for each of the screen buckets: Large, Medium and Small. In ResponsiveWidget's build function, appropriate implementation will be picked like below:

class ResponsiveWidget {
  ...
  final Widget largeScreen;
  final Widget mediumScreen;
  final Widget smallScreen;

  const ResponsiveWidget(
      {Key key, this.largeScreen, this.mediumScreen, this.smallScreen})
      : super(key: key);

  @override
  Widget build(BuildContext context) {
    //Returns the widget which is more appropriate for the screen size
    return LayoutBuilder(builder: (context, constraints) {
      if (constraints.maxWidth > 1200) {
        return largeScreen;
      } else if (constraints.maxWidth > 800 && constraints.maxWidth < 1200) {
        //if medium screen not available, then return large screen
        return mediumScreen ?? largeScreen;
      } else {
        //if small screen implementation not available, then return large screen
        return smallScreen ?? largeScreen;
      }
    });
  }
}

Adapting landing page's Body

This is how Body's widget look like from my previous posts. To make it responsive, we'll need different design implementations for each of the screen bucket. To keep things simple, I'll create only two layout implementations in this tutorial: Large and Small. Anything in Medium bucket will fall back to Large layout.

class Body extends StatelessWidget {

  @override
  Widget build(BuildContext context) {
    return SizedBox(
      height: 600,
      child: Stack(
        fit: StackFit.expand,
        children: <Widget>[
          addBackground(),
          addWelcomeText()
        ],
      ),
    );
  }
  ....
}

Our target Body widget build method to look like this:

import 'package:landingpage/utils/responsive_widget.dart';
class Body extends StatelessWidget {

@override
  Widget build(BuildContext context) {
    return ResponsiveWidget(
      largeScreen: LargeScreen(),
      smallScreen: SmallScreen(),
    );
  }
  ...
}

As you see that I imported responsive_widget.dart, and provided two implementations: LargeScreen() and SmallScreen(). One of the implementation will be rendered based on the screen size at runtime. You might have noticed that I've not provided MediumScreen(). In that case, it will fall back to LargeScreen() widget. Okay, let's get started implementing LargeScreen() first. Basically, we'll move existing layout into LargeScreen(). At this point large screen layout will look like this:

For SmallScreen(), we might need to do few tinkering. Like we need to put things in a Column inside SingleChildScrollView, and add all other widgets as its children. We do this to fit all widgets in vertical view to make every widget accessible when width is not sufficient to layout in horizontal manner. This is how SmallScreen() implementation will look like:

class SmallScreen extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return SingleChildScrollView(
      child: Padding(
        padding: EdgeInsets.all(40),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: <Widget>[
            Text(
              Strings.hello,
              style: TextStyle(
                fontWeight: FontWeight.bold,
                fontSize: 40,
                color: MyColors.blue4,
              ),
            ),
            RichText(
              text: TextSpan(
                  text: Strings.welcomeTo,
                  style: TextStyle(fontSize: 40, color: MyColors.blue4),
                  children: [
                    TextSpan(
                        text: Strings.ftf,
                        style: TextStyle(
                            fontSize: 40,
                            fontWeight: FontWeight.bold,
                            color: Colors.black54))
                  ]),
            ),
            SizedBox(
              height: 30,
            ),
            Center(
              child: Image.network(
                backgroundImage,
                scale: 1,
              ),
            ),
            Padding(
              padding: EdgeInsets.only(left: 12.0, top: 20),
              child: Text(Strings.subscribeText),
            ),
            SizedBox(
              height: 30,
            ),
            EmailBox(),
            SizedBox(
              height: 30,
            )
          ],
        ),
      ),
    );
  }
}

At this point small screen layout will look like below. You'll notice that background image is moved to bottom under the welcome text, and above the "subscribe to keep informed" text. In larger screen background image was towards the right side of the page. This is because we've added background image below the welcome text. Observe the code snippet above. Overall landing page on small screen looks balanced.

However, there're still two issues with this layout: First, "EmailBox" to inputting email addresses is aligned towards left and far away from right side. This is because of right padding "74". We would need to make it to same as of left side padding to keep this box in center. Let's set EmailBox widget right padding to "4" for smaller screens.

class EmailBox extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Padding(
      padding: EdgeInsets.only(
          left: 4.0,
          right: ResponsiveWidget.isSmallScreen(context) ? 4: 74, //Check for screen type
          top: 10,
          bottom: 40),
          ....

    }
}

Second, you might notice that "Subscribe" button still have overflow text like shown in screenshot below:

Let's fix the overflow text issue with SubscribeButton. There're three places, where we need to adjust the size rendering to fit on smaller screens.

Make the font of the text "Subscribe" on button adaptive to the screen at run time.

Text(
    Strings.subscribeButton,
    style: TextStyle(
        color: MyColors.white1,
        fontSize: ResponsiveWidget.isSmallScreen(context)
            ? 12
            : ResponsiveWidget.isMediumScreen(context)
                ? 12
                : 16,
        letterSpacing: 1),
  ),

Make spacing between text and image adaptive to the screen at run time. On Smaller screen make it 4, on medium 6 and for larger screens 8.

SizedBox(
  width: ResponsiveWidget.isSmallScreen(context)
      ? 4
      : ResponsiveWidget.isMediumScreen(context) ? 6 : 8,
),

Last thing is to make image size adjustable to screen size.

Image.network(
  emailImage,
  color: MyColors.white1,
  width: ResponsiveWidget.isSmallScreen(context)
      ? 12
      : ResponsiveWidget.isMediumScreen(context) ? 12 : 20,
  height: ResponsiveWidget.isSmallScreen(context)
      ? 12
      : ResponsiveWidget.isMediumScreen(context) ? 12 : 20,
)

However this doesn't solve the problem fully. For small screens "Subscribe" text and "email" icon is just too much to adjust together next to each other. So you've to be creative with your design here. In my case, I only used email image for button and skipped "Subscribe" text on button. I created two different variants for buttons. One for smaller screen and another for larger screen.

Widget buildButton(BuildContext context) {
  if (ResponsiveWidget.isSmallScreen(context))
    return buildSmallButton(context);
  else
    return buildLargeButton(context);
}

Here, I'm showing only small button implementation. Refer to code to checkout our large button implementation.

Widget buildSmallButton(BuildContext context) {
  return Row(
    mainAxisAlignment: MainAxisAlignment.center,
    children: <Widget>[
      Image.network(
        emailImage,
        color: MyColors.white1,
        width: ResponsiveWidget.isSmallScreen(context)
            ? 12
            : ResponsiveWidget.isMediumScreen(context) ? 12 : 20,
        height: ResponsiveWidget.isSmallScreen(context)
            ? 12
            : ResponsiveWidget.isMediumScreen(context) ? 12 : 20,
      )
    ],
  );
}

Note: I'm using Chrome's inspect mode to checkout layout on different screen layouts.

Screenshot below shows the Small button :

At this point, we've made body of the landing page responsive. Now let's make header responsive.

Adapting landing page's Header

In large screens, there's enough room to show all navigation links. However, as far as smaller screens are concerned, there's not enough space to show all links next to each other. For smaller screens, it makes sense to show a menu icon. Clicking on menu icon can bring up all the links. Implementing menu icon interaction is out of the scope of this article.

class Header {
  ...
  //Builds navigation links at the right top of landing page
  Widget buildHeaderLinks(BuildContext context) {
    if (!ResponsiveWidget.isSmallScreen(context))
      return Row(
        mainAxisAlignment: MainAxisAlignment.spaceAround,
        children: getLinksListing()..add(buildLoginButton()),
      );
    else
      return Image.network("assets/menu.png", width: 25, height: 25);
  }
  ...
}

Note: Image.network needs to be replaced with Image.asset for Native implementation.

So, this concludes making landing page responsive for all screen form factors.

Running in Native environment

You may want to make few changes to adapt to native code. I've native source code available here

Image.network needs to be replaced with Image.asset.
flutter_web imports need to be replaced with it's native variant flutter.

Responsive page at Native platform looks like below in Android:

Keep Fluttering !

Source code repo:

Source code for web
Source code for Native
Youtube playlist for Designing Flutter Landing page

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Designing Cross platform Flutter prototype for Landing Page (Web-Hummingbird, Android, iOS)

2019-06-03T00:00:00-04:00

Introduction

This post is about how to design landing page for a hypothetical mobile and web app for Flutter resources say "Flutter-to-Fly !". This post will have two sections to it:

Flutter-to-fly landing page for Web (web branch of source code).
Flutter-to-fly landing page for Native Android and iOS platforms (native branch of source code).

Checkout the companion video tutorial Part - 1:

Checkout the companion video tutorial Part - 2:

Part-1: Flutter-to-fly landing page for Web

Note: As of now (June 3rd, 2019), there's no actually one code base solution exists for cross-platform Flutter. Web app's code uses specific web libraries. Plug-ins used in flutter native apps can't be used in web apps. Its recommended to create a git branch to host web app code for now until web comes out of tech-preview and experimentation.

Setup:

Create a Flutter Project in Android Studio.
Create a git branch web
Copy pubspec.yaml to pubspec.yaml.native for backing up native platform settings. We would need this for native project in another branch say master. I would keep native code in default branch master.

Configuring pubspec.yaml: Adapt pubspec.yaml for Web as described in this link. This is how pubspec.yaml for web app will look like:

name: landingpage
description: Cross platform sample landing page implemented in Flutter

version: 1.0.0+1

dependencies:
  flutter_web: any

dev_dependencies:
  flutter_web_test: any
  #dependencies to enable the Dart web build system
  build_runner: ^1.2.2
  build_web_compilers: ^1.1.0
  test: ^1.3.4

  ## These overrides tell the package tools to get them from GitHub
dependency_overrides:
  flutter_web:
    git:
      url: https://github.com/flutter/flutter_web
      path: packages/flutter_web
  flutter_web_ui:
    git:
      url: https://github.com/flutter/flutter_web
      path: packages/flutter_web_ui
  flutter_web_test:
    git:
      url: https://github.com/flutter/flutter_web
      path: packages/flutter_web_test

Create web directory: Create a web directory to host the entry point for the web app at root level (same level as lib directory). web/index.html and web/main.dart needs to be added as mentioned here

Building web app: Navigate to current working directory and get all dependencies.

cd landingpage
pub get

Dart uses webdev to build and run project. Make sure to activate webdev before building project like below. Don't forget to include it in system PATH using export PATH="$PATH":"$HOME/.pub-cache/bin" after activation.

pub global activate webdev
webdev serve

Web app will start running at localhost port 8080

Note: Make sure that you've replaced all package:flutter packages with package:flutter_web variant.

At this point, we're done with setting up Flutter project to start building web app. You'll see default counter app running, provided as part of built-in examples.

Step1: Getting ready & Page Header

Clean up the pre-generated code by Flutter. Make MyHomePage Stateless widget. Remove the title passed into MyHomePage. Update the title of the app to Flutter to fly !. This is how your main.dart should look like:

import 'package:flutter_web/material.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter to fly !',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: MyHomePage(),
    );
  }
}

class MyHomePage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    // TODO: implement build
    return null;
  }

}

Now, lets add header and body for the landing page. Header will have site's logo and navigation links. Body will have background image, text box to submit emails to subscribe to mailing list for any content updates.

First, add a linear gradient on the whole page using two different shades of white (I created a class MyColors.dart to hold all my custom colors).

@override
  Widget build(BuildContext context) {
    //Add a container and provide a linear gradient.
    //basically use different shades of same color.
    return Container(
      decoration: BoxDecoration(
          gradient: LinearGradient(colors: [MyColors.white1, MyColors.white2])),
    );
  }

Add a Scaffold as child to Container above to hold the whole page like below:

class MyHomePage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    //Add a container and provide a linear gradient.
    //basically use different shades of same color.
    return Container(
      decoration: BoxDecoration(
          gradient: LinearGradient(colors: [MyColors.white1, MyColors.white2])),
      child: Scaffold(
        backgroundColor: Colors.transparent,
        body: SingleChildScrollView(
          child: Column(
            children: <Widget>[Header(), Body()],
          ),
        ),
      ),
    );
  }
}

SingleChildScrollView will contain header and body of the page. I've created two classes: Header and Body to help us with header and body section/widgets.

Header Widget Header section/widget contains logo and site's title at left side, and navigation links and login button at right side. I'll use Padding widget to contain header section's logo and links.

Below is the code snippet that's responsible for generating logo above:

//Builds rectangle with circular corners and Text on it and next to it as title
Widget buildLogo() {
  return Row(
    children: <Widget>[
      Container(
        width: 60,
        height: 60,
        decoration: BoxDecoration(
          borderRadius: BorderRadius.circular(18),
          gradient: LinearGradient(colors: [MyColors.blue1, MyColors.blue2],
          begin: Alignment.bottomRight, end: Alignment.topLeft),
        ),
        child: Center(
          child: Text(Strings.logoTitle,
          style: TextStyle(fontSize: 30, color: MyColors.white1),),
        ),
      ),
      //give some space between logo box and title
      SizedBox(
        width: 16,
      ),
      Text(Strings.appTitle, style: TextStyle(fontSize: 26),)
    ],
  );
}

LogIn Button:

//Builds and decorates login button
Widget buildLoginButton() {
  return Padding(
    padding: EdgeInsets.all(8.0),
    child: InkWell(
      child: Container(
        margin: EdgeInsets.only(left: 20),
        width: 120,
        height: 40,
        decoration: BoxDecoration(
          gradient: LinearGradient(colors: [
            MyColors.blue1, MyColors.blue2
          ],
          begin: Alignment.bottomRight,
          end: Alignment.topLeft),
          borderRadius: BorderRadius.circular(20),
          boxShadow: [
            BoxShadow(
              color: MyColors.blue3.withOpacity(0.3),
              offset: Offset(0, 8), //Shadow starts at x=0, y=8
              blurRadius: 8
            )
          ]
        ),
        child: Material(
          color: Colors.transparent,
          child: Center(
            child: Text(Strings.loginButton,
            style: TextStyle(
              color: MyColors.white1,
              fontSize: 18,
              letterSpacing: 1
            ),),
          ),
        ),
      ),
    ),
  );
}

Header Navigation Links: Now add header navigation links just before the login button created above to finish header section.

Get the list of links to be shown in the header:

//Builds navigation list for header
List<Widget> getLinksListing() {
  var links = ["Home", "Samples", "Videos", "Plugins"];
  return links.map((link) {
    return Padding(
      padding: EdgeInsets.only(left: 18),
      child: Text(
        link,
        style: TextStyle(fontSize: 15, fontWeight: FontWeight.bold),
      ),
    );
  }).toList();
}

Add links listing to Header:

//Builds navigation links at the right top of landing page
Widget buildHeaderLinks() {
  return Row(
    mainAxisAlignment: MainAxisAlignment.spaceAround,
    children: getLinksListing()..add(buildLoginButton()),
  );
}

Finally, build header widget:

@override
Widget build(BuildContext context) {
  return Padding(
    padding: EdgeInsets.symmetric(horizontal: 45, vertical: 38),
    child: buildHeader(),
  );
}

Widget buildHeader() {
  return Row(
    mainAxisAlignment: MainAxisAlignment.spaceBetween,
    children: <Widget>[buildLogo(), buildHeaderLinks()],
  );
}

This is how header looks at this point:

We're done with header for now. Let's move to body section in Step2.

Step2: Page Body:

Body section has three components to it. * Background image showing flutter art work. * Welcome text. * Mailing list subscription: Text box to let user enter their email addresses to subscribe to the newsletter.

Adding Background image: All images goes inside web/assets directory. Background image is added aligned to right side of the page.

//Adds background Image
Widget addBackground() {
  return FractionallySizedBox(
    alignment: Alignment.centerRight, //to keep images aligned to right
    widthFactor: .6, //covers about 60% of the screen width
    child: Image.network(backgroundImage, scale: .85,),
  );
}

Let's work on welcome text title.

Adding Welcome Text: I've added welcome text at this point, and it looks like below:

//Adds welcome text
Widget addWelcomeText() {
  return FractionallySizedBox(
    alignment: Alignment.centerLeft, //text aligned to left side
    widthFactor: .6, //covers about half of the screen
    child: Padding(
      padding: EdgeInsets.only(left: 48),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        mainAxisAlignment: MainAxisAlignment.center,
        children: <Widget>[
          Text(
            Strings.hello,
            style: TextStyle(
              fontWeight: FontWeight.bold,
              fontSize: 60,
              color: MyColors.blue4,
            ),
          ),
          RichText(
            text: TextSpan(
              text: Strings.welcomeTo,
              style: TextStyle(
                fontSize: 60,
                color: MyColors.blue4
              ),
              children: [
                TextSpan(
                  text: Strings.ftf,
                  style: TextStyle(
                    fontSize: 60,
                    fontWeight: FontWeight.bold,
                    color: Colors.black54
                  )
                )
              ]
            ),
          ),
          Padding(
            padding: EdgeInsets.only(left: 12.0, top: 20),
            child: Text(Strings.subscribeText),
          ),
          SizedBox(height: 40,), //Give some spacing
          EmailBox() //Alert : this will be added after next step
        ],
      ),
    ),
  );
}

Let's work on the third part of the body section: users inputting their email addresses in text box to subscribe to site.

Mailing list subscription: There're two parts to this component. One is text box for user to enter email addresses. Let's call this widget EmailBox. Another is button to click on to subscribe. I'm naming this widget as SubscribeButton

Here's how EmailBox code looks like:

class EmailBox extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Padding(
      padding: EdgeInsets.only(left: 4.0, right: 74, top: 10, bottom: 40),
      child: Container(
        height: 60,
        decoration: BoxDecoration(
            color: MyColors.white1,
            borderRadius: BorderRadius.circular(20),
            boxShadow: [
              BoxShadow(
                  color: Colors.black12, offset: Offset(0, 8), blurRadius: 8)
            ]),
        child: Padding(
          padding: EdgeInsets.symmetric(horizontal: 20),
          child: Row(
            mainAxisAlignment: MainAxisAlignment.spaceBetween,
            children: <Widget>[
              Expanded(
                flex: 8,
                child: TextField(
                  decoration: InputDecoration(
                      border: InputBorder.none, hintText: Strings.email_hint),
                ),
              ),
              Expanded(
                flex: 2,
                child: SubscribeButton(),
              )
            ],
          ),
        ),
      ),
    );
  }
}

SubscribeButton is called from EmailBox. SubscribeButton widget looks like below:

import 'package:flutter_web/material.dart';
import 'package:landingpage/utils/myColors.dart';
import 'package:landingpage/utils/strings.dart';

class SubscribeButton extends StatelessWidget {
  var emailImage = "assets/email.png";

  @override
  Widget build(BuildContext context) {
    return InkWell(
      child: Container(
        height: 40,
        decoration: BoxDecoration(
            gradient: LinearGradient(
                colors: [MyColors.blue1, MyColors.blue2],
                begin: Alignment.bottomRight,
                end: Alignment.topLeft),
            borderRadius: BorderRadius.circular(20.0),
            boxShadow: [
              BoxShadow(
                  color: MyColors.blue3.withOpacity(.3),
                  offset: Offset(0, 8),
                  blurRadius: 8.0)
            ]),
        child: Material(
          color: Colors.transparent,
          child: InkWell(
            onTap: () {}, //TODO
            child: Center(
              child: Row(
                mainAxisAlignment: MainAxisAlignment.center,
                children: <Widget>[
                  Text(
                    Strings.subscribeButton,
                    style: TextStyle(
                        color: MyColors.white1, fontSize: 16, letterSpacing: 1),
                  ),
                  SizedBox(
                    width: 8,
                  ),
                  Image.network(
                    emailImage,
                    color: MyColors.white1,
                    width: 20,
                    height: 20,
                  )
                ],
              ),
            ),
          ),
        ),
      ),
    );
  }
}

The final landing page looks like this:

Checkout my article about making this page responsive

Part-2: Flutter-to-fly landing page for Native platform

I want to show you how this code can be converted into native, and can be built and run on Android and iOS platforms. First we need to create a separate branch and adapt its pubspec.yaml for native Flutter. Remember that you can use any plug-ins in native code, but not in web variation at this point. So, it makes sense to create web app first and then adapt it at native platform. As I mentioned before that you would need to replace flutter_web to flutter packages. Note: You may need to refresh packages in native environment. Don't forget to update the assets in appropriate location for Flutter native.

I've created branch named native to play around in Android and iOS platforms. At this point, I see few dimensions issues there since layout is designed for large screen point of view. In next post, I'll explain how we can make it responsive on different form factors.

Until then keep Fluttering !

Source code repo:

Next Article: Make landing page responsive

References/Credits:

Migration to Web
I've adapted design of "Flutter-to-fly" hypothetical app's landing page from this dribble design
Adapted this web app example to Native Flutter platforms to demonstrate Flutter's cross-platform support.

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Implementing Search action in AppBar

2019-02-06T00:00:00-05:00

Search in AppBar

In today's recipe, I'll show you how search action can be integrated at top of the page. I'll be using Flutter's SearchDelegate component to achieve this. It comes packed with support for populating suggestions in search bar, adding actions items to the right side of the search bar. I'm using dart's library english_words to populate the list of words.

Target Audience: Beginner

Recipe: Implementing Search action in AppBar using Flutter for Android and iOS mobile apps.

Focus Widget: SearchDelegate

Goal: In this recipe, I'll show you : 1. How to populate sorted english word list in app and search for a given word using Search bar at the top of the application. 2. How to build suggestion list for search bar. 3. How to add actions like "clear" to reset search bar, and a dummy action "mic" for voice input.

Checkout in action:

Lets's go!

Step #0: Create "Flutter Application" project in Android Studio.

Step #1. Get dependencies. First thing to add english_words dependency in pubspec.yaml to be able to populate English words in our recipe app's word list.

dependencies:
  flutter:
    sdk: flutter
  # This is needed to populate English words in app's word list.
  english_words: ^3.1.3

Step #2. Display Word list To display English word list as list in app, first thing is to import the dependency in main.dart file:

import 'package:english_words/english_words.dart' as words;

Step #3. Initialize word list in SearchAppBarRecipeState class. Now, in the _SearchAppBarRecipeState class, fetch the list of words like below. Make sure that you've a list data structure to hold word list. I'm using kWords for this purpose.

class _SearchAppBarRecipeState extends State<SeachAppBarRecipe> {
  //Data structure to hold word list
  final List<String> kWords;

  ...

    //Initializing kWords list with data fetched from english_words library
  _SearchAppBarRecipeState()
      : kWords = List.from(Set.from(words.all)),
        super();

  ...
}

Step #4. Sorting word list. You'll notice at this point that data is un-sorted at this point. Let's make it alphabetically sorted as below:

class _SearchAppBarRecipeState extends State<SeachAppBarRecipe> {
  final List<String> kWords;
  ...

  //Initializing with sorted list of english words
  _SearchAppBarRecipeState()
      : kWords = List.from(Set.from(words.all))
    ..sort(
          (w1, w2) => w1.toLowerCase().compareTo(w2.toLowerCase()),
    ),
        super();
   ...
}

Step #5. Setup SearchDelegate to implement Search AppBar. Search delegate is where all the magic happens. It holds two list of words. One list is of the general word list passed during initialization. Another list _history contains the list of history words. You can pre-populate _history list to give a baseline for history search items. This list will be shown when user clicks on the search bar.

class _SearchAppBarDelegate extends SearchDelegate<String> {
  //list holds the full word list
  final List<String> _words;

  //list holds history search words.
  final List<String> _history;

    //initialize delegate with full word list and history words
  _SearchAppBarDelegate(List<String> words)
      : _words = words,
  //pre-populated history of words
        _history = <String>['apple', 'orange', 'banana', 'watermelon'],
        super();

  ...
}

Step #6. After setting up words list options in delegate, now its time to pick up an icon that will be placed at the left side of search bar. Mostly, this icon menu is meant for navigating back to previous screen.

class _SearchAppBarDelegate extends SearchDelegate<String> {
  ...

    // Setting leading icon for the search bar.
    //Clicking on back arrow will take control to main page
    @override
    Widget buildLeading(BuildContext context) {
      return IconButton(
        tooltip: 'Back',
        icon: AnimatedIcon(
          icon: AnimatedIcons.menu_arrow,
          progress: transitionAnimation,
        ),
        onPressed: () {
          //Take control back to previous page
          this.close(context, null);
        },
      );
    }

  ...
}

Alright we got the icon for search bar ! What next ?

Step #7. Now it's time to implement buildResults method to show searched item. This is where search query this.query will display searched item. For sake of simplicity, I'll be adding two widgets only. First widget is Text and will display message '===Your Word Choice==='. Second widget is GestureDetector which has it's another Text widget as its child. Tapping on the Text widget will take control back to previous page along with this.query parameter to display the searched word in main page.

class _SearchAppBarDelegate extends SearchDelegate<String> {
  ...

  //Builds page to populate search results.
  @override
  Widget buildResults(BuildContext context) {
    return Padding(
      padding: const EdgeInsets.all(8.0),
      child: Center(
        child: Column(
          mainAxisSize: MainAxisSize.min,
          children: <Widget>[
            Text('===Your Word Choice==='),
            GestureDetector(
              onTap: () {
                //Define your action when clicking on result item.
                //In this example, it simply closes the page
                this.close(context, this.query);
              },
              child: Text(
                this.query,
                style: Theme.of(context)
                    .textTheme
                    .display2
                    .copyWith(fontWeight: FontWeight.normal),
              ),
            ),
          ],
        ),
      ),
    );
  }

  ...
}

Step #8. Next, it's time for implementing buildSuggestions method of SearchDelegate class. So, what does building suggestions mean ? This is the list of suggestions for words that you'll see when typing your search query in search bar. There're two parts of this. First, we've to pass the list of words that could be displayed as suggestions. Second, we need to implement the UI widget to display this suggestion list.

For data part, we display pre-populated history words when query term is empty. When user starts typing then we show all the words that starts with search terms entered in search bar. That's it !

class _SearchAppBarDelegate extends SearchDelegate<String> {
  ...

  // Suggestions list while typing search query - this.query.
  @override
  Widget buildSuggestions(BuildContext context) {
    final Iterable<String> suggestions = this.query.isEmpty
        ? _history
        : _words.where((word) => word.startsWith(query));

        ...
  }

  ...
}

It's UI widget's turn now. As you can see buildSuggestions method returns a Widget. We'll make a separate class say _WordSuggestionList to populate suggestion list widget and will return it from buildSuggestions. _WordSuggestionList is going to be a StatelessWidget, and has three things: First, list of suggestions. Second, search query and last a callback say ValueChanged<String> onSelected. It'll be ListView of size of number of suggestions provided. Each suggestion is displayed in ListTile widget. This widget will show history icon for items fetched from pre-populated history words only. Text for widget will be updated as user is typing the search query.

class _WordSuggestionList extends StatelessWidget {
  const _WordSuggestionList({this.suggestions, this.query, this.onSelected});

  final List<String> suggestions;
  final String query;
  final ValueChanged<String> onSelected;

  @override
  Widget build(BuildContext context) {
    final textTheme = Theme.of(context).textTheme.subhead;
    return ListView.builder(
      itemCount: suggestions.length,
      itemBuilder: (BuildContext context, int i) {
        final String suggestion = suggestions[i];
        return ListTile(
          leading: query.isEmpty ? Icon(Icons.history) : Icon(null),
          // Highlight the substring that matched the query.
          title: RichText(
            text: TextSpan(
              text: suggestion.substring(0, query.length),
              style: textTheme.copyWith(fontWeight: FontWeight.bold),
              children: <TextSpan>[
                TextSpan(
                  text: suggestion.substring(query.length),
                  style: textTheme,
                ),
              ],
            ),
          ),
          onTap: () {
            onSelected(suggestion);
          },
        );
      },
    );
  }
}

Let's plug-in _WordSuggestionList back into buildSuggestions method:

class _SearchAppBarDelegate extends SearchDelegate<String> {
  ...

  // Suggestions list while typing search query - this.query.
  @override
  Widget buildSuggestions(BuildContext context) {
    final Iterable<String> suggestions = this.query.isEmpty
        ? _history
        : _words.where((word) => word.startsWith(query));

    //calling wordsuggestion list    
    return _WordSuggestionList(
          query: this.query,
          suggestions: suggestions.toList(),
          onSelected: (String suggestion) {
            this.query = suggestion;
            this._history.insert(0, suggestion);
            showResults(context);
          },
  }

  ...
}

Step #9. Building actions in SearchBar. Last step is to add action menus in SearchBar's right side. I'll be adding two menu actions. One is "Clear" icon to clear search query from search bar. Another is a "mic" icon, that could be improved to accept voice input, which is beyond the scope of this recipe. However, if you would like me to write about another recipe for accepting voice input, feel free to contact me as mentioned at the end of this post.

class _SearchAppBarDelegate extends SearchDelegate<String> {
  ...

// Action buttons at the right of search bar.
  @override
  List<Widget> buildActions(BuildContext context) {
    return <Widget>[
      query.isNotEmpty ?
      IconButton(
        tooltip: 'Clear',
        icon: const Icon(Icons.clear),
        onPressed: () {
          query = '';
          showSuggestions(context);
        },
      ) : IconButton(
        icon: const Icon(Icons.mic),
        tooltip: 'Voice input',
        onPressed: () {
          this.query = 'TBW: Get input from voice';
        },

      ),
    ];
  }

  ...
}

Step #10. Finally, call Search Delegate from SearchAppBarRecipeState. After creating SearchDelegate class, call it from _SearchAppBarRecipeState class and initialize it in initState.

class _SearchAppBarRecipeState extends State<SeachAppBarRecipe> {
    final List<String> kWords;

    //Calling search delegate class
    _SearchAppBarDelegate _searchDelegate;
    ...

    @override
    void initState() {
       super.initState();
       //Initializing search delegate with sorted list of English words
       _searchDelegate = _SearchAppBarDelegate(kWords);
    }

    ...
}

That's it !

Complete example code

import 'package:flutter/material.dart';
import 'package:english_words/english_words.dart' as words;

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'SeachAppBarRecipe',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: SeachAppBarRecipe(title: 'SeachAppBarRecipe'),
    );
  }
}

class SeachAppBarRecipe extends StatefulWidget {
  SeachAppBarRecipe({Key key, this.title}) : super(key: key);

  final String title;

  @override
  _SearchAppBarRecipeState createState() => _SearchAppBarRecipeState();
}

class _SearchAppBarRecipeState extends State<SeachAppBarRecipe> {
  final List<String> kWords;
  _SearchAppBarDelegate _searchDelegate;

  //Initializing with sorted list of english words
  _SearchAppBarRecipeState()
      : kWords = List.from(Set.from(words.all))
    ..sort(
          (w1, w2) => w1.toLowerCase().compareTo(w2.toLowerCase()),
    ),
        super();


  @override
  void initState() {
    super.initState();
    //Initializing search delegate with sorted list of English words
    _searchDelegate = _SearchAppBarDelegate(kWords);
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        automaticallyImplyLeading: false,
        title: Text('Word List'),
        actions: <Widget>[
          //Adding the search widget in AppBar
          IconButton(
            tooltip: 'Search',
            icon: const Icon(Icons.search),
            //Don't block the main thread
            onPressed: () {
              showSearchPage(context, _searchDelegate);
            },
          ),
        ],
      ),
      body: Scrollbar(
        //Displaying all English words in list in app's main page
        child: ListView.builder(
          itemCount: kWords.length,
          itemBuilder: (context, idx) =>
              ListTile(
                title: Text(kWords[idx]),
                onTap: () {
                  Scaffold.of(context).showSnackBar(
                      SnackBar(
                          content: Text("Click the Search action"),
                          action: SnackBarAction(
                            label: 'Search',
                            onPressed: (){
                              showSearchPage(context, _searchDelegate);
                            },
                          )
                      )
                  );
                },
              ),
        ),
      ),
    );
  }

  //Shows Search result
  void showSearchPage(BuildContext context,
      _SearchAppBarDelegate searchDelegate) async {
    final String selected = await showSearch<String>(
      context: context,
      delegate: searchDelegate,
    );

    if (selected != null) {
      Scaffold.of(context).showSnackBar(
        SnackBar(
          content: Text('Your Word Choice: $selected'),
        ),
      );
    }
  }
}

//Search delegate
class _SearchAppBarDelegate extends SearchDelegate<String> {
  final List<String> _words;
  final List<String> _history;

  _SearchAppBarDelegate(List<String> words)
      : _words = words,
  //pre-populated history of words
        _history = <String>['apple', 'orange', 'banana', 'watermelon'],
        super();

  // Setting leading icon for the search bar.
  //Clicking on back arrow will take control to main page
  @override
  Widget buildLeading(BuildContext context) {
    return IconButton(
      tooltip: 'Back',
      icon: AnimatedIcon(
        icon: AnimatedIcons.menu_arrow,
        progress: transitionAnimation,
      ),
      onPressed: () {
        //Take control back to previous page
        this.close(context, null);
      },
    );
  }

  // Builds page to populate search results.
  @override
  Widget buildResults(BuildContext context) {
    return Padding(
      padding: const EdgeInsets.all(8.0),
      child: Center(
        child: Column(
          mainAxisSize: MainAxisSize.min,
          children: <Widget>[
            Text('===Your Word Choice==='),
            GestureDetector(
              onTap: () {
                //Define your action when clicking on result item.
                //In this example, it simply closes the page
                this.close(context, this.query);
              },
              child: Text(
                this.query,
                style: Theme.of(context)
                    .textTheme
                    .display2
                    .copyWith(fontWeight: FontWeight.normal),
              ),
            ),
          ],
        ),
      ),
    );
  }

  // Suggestions list while typing search query - this.query.
  @override
  Widget buildSuggestions(BuildContext context) {
    final Iterable<String> suggestions = this.query.isEmpty
        ? _history
        : _words.where((word) => word.startsWith(query));

    return _WordSuggestionList(
      query: this.query,
      suggestions: suggestions.toList(),
      onSelected: (String suggestion) {
        this.query = suggestion;
        this._history.insert(0, suggestion);
        showResults(context);
      },
    );
  }

  // Action buttons at the right of search bar.
  @override
  List<Widget> buildActions(BuildContext context) {
    return <Widget>[
      query.isNotEmpty ?
      IconButton(
        tooltip: 'Clear',
        icon: const Icon(Icons.clear),
        onPressed: () {
          query = '';
          showSuggestions(context);
        },
      ) : IconButton(
        icon: const Icon(Icons.mic),
        tooltip: 'Voice input',
        onPressed: () {
          this.query = 'TBW: Get input from voice';
        },

      ),
    ];
  }
}

// Suggestions list widget displayed in the search page.
class _WordSuggestionList extends StatelessWidget {
  const _WordSuggestionList({this.suggestions, this.query, this.onSelected});

  final List<String> suggestions;
  final String query;
  final ValueChanged<String> onSelected;

  @override
  Widget build(BuildContext context) {
    final textTheme = Theme.of(context).textTheme.subhead;
    return ListView.builder(
      itemCount: suggestions.length,
      itemBuilder: (BuildContext context, int i) {
        final String suggestion = suggestions[i];
        return ListTile(
          leading: query.isEmpty ? Icon(Icons.history) : Icon(null),
          // Highlight the substring that matched the query.
          title: RichText(
            text: TextSpan(
              text: suggestion.substring(0, query.length),
              style: textTheme.copyWith(fontWeight: FontWeight.bold),
              children: <TextSpan>[
                TextSpan(
                  text: suggestion.substring(query.length),
                  style: textTheme,
                ),
              ],
            ),
          ),
          onTap: () {
            onSelected(suggestion);
          },
        );
      },
    );
  }
}

Source code repo: Recipe source code is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

BottomNavigationBar with menu, search and overflow action items

2019-02-05T00:00:00-05:00

BottomNavigationBar

BottomNavigationBar is used to put action menus at the bottom of a Flutter app. This widget is useful to put actions menus intended for the current page. This recipe will show how to implement a bottom navigation bar with a menu to open drawer for more action items like "add" & "edit", a "search" menu action and finally an overflow menu action item.

Target Audience: Beginner

Recipe: Implement a BottomNavigationBar using BottomAppBar with menu, search and overflow action items.

Focus Widget: BottomAppBar

Goal: BottomNavigationBar displays a menu to bring up bottom navigation drawer, a dummy search action icon and overflow action items menu. Clicking on each menu action will display a message using Fluttertoast

Checkout in action:

Lets's go!

Step #1. Since we'll be using fluttertoast for showing status messages, first we'll be adding fluttertoast library dependency in pubspec.yaml like below:

dependencies:
  flutter:
    sdk: flutter
  #added fluttertoast library to show status messages
  fluttertoast: ^2.1.0

Click on get/upgrade dependencies when prompt is shown. You may want to make sure that all dependencies are refreshed.

Step #2. Add a placeholder top part for the app using Center widget. I'll be using Text widget to show demo message.

Widget build(BuildContext context) {
    return Scaffold(
      body: Center(
        child: Text('Checkout BottomNavigationBar in action below'),
      ),
    ...

    );
  }

Step #3. Add BottomAppBar widget using bottomNavigationBar attribute.

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      ...

      bottomNavigationBar: BottomAppBar(
          ...
    );
  }

Step #4. Add child component Row to BottomAppBar.

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      ...

      bottomNavigationBar: BottomAppBar(
        child: Row(

        ),
          ...
    );
  }

Step #5. Now, its time to add menu action widgets. Widgets are added as children to Row component.

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      ...

      bottomNavigationBar: BottomAppBar(
        child: Row(
            children: <Widget>[
                ...
            ],
        ),
          ...
    );
  }

Step #6. Next, I'll add our very first menu action item as first child menu action widget. I'll be using IconButton widget. When this action menu is clicked, it'll open ModalBottomSheet.

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      ...

      bottomNavigationBar: BottomAppBar(
        child: Row(
            children: <Widget>[
                // Bottom that pops up from the bottom of the screen.
                IconButton(
                    icon: Icon(Icons.menu),
                    onPressed: () {
                      showModalBottomSheet<Null>(
                        context: context,
                        builder: (BuildContext context) => openBottomDrawer(),
                      );
                    },
                ),
            ],
        ),
          ...
    );
  }

Drawer opened in modal bottom sheet has two menu actions for "Edit" and "Add". It looks like this:

Widget openBottomDrawer() {
    return Drawer(
      child: Column(
        children: const <Widget>[
          //Add menu item to edit
          const ListTile(
            leading: const Icon(Icons.mode_edit),
            title: const Text('Edit'),
          ),
          const ListTile(
            //Add menu item to add a new item
            leading: const Icon(Icons.add),
            title: const Text('Add'),
          ),
        ],
      ),
    );
  }

Step #7. Two more IconButton widgets are added for "Search" and overflow menu action items as children widgets.

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      ...

      bottomNavigationBar: BottomAppBar(
        child: Row(
            children: <Widget>[
                //First action menu widget
                // Bottom that pops up from the bottom of the screen.
                IconButton(
                    icon: Icon(Icons.menu),
                    onPressed: () {
                      showModalBottomSheet<Null>(
                        context: context,
                        builder: (BuildContext context) => openBottomDrawer(),
                      );
                    },
                ),

                //Second action menu widget for Search
                IconButton(
                    icon: Icon(Icons.search),
                    onPressed: () {
                      Fluttertoast.showToast(msg: 'Clicked on Search menu action.');
                    },
                ),   

                //Third action menu widget for overflow action
                IconButton(
                    icon: const Icon(Icons.more_vert),
                    onPressed: () {
                      Fluttertoast.showToast(msg: 'This is where overflow menu actions will go');
                    },
                ),
            ],
        ),
    );
  }

Complete example code

import 'package:flutter/material.dart';
import 'package:fluttertoast/fluttertoast.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'BottomNavigationBarRecipe',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: BottomNavigationBarRecipe(title: 'Flutter Demo Home Page'),
    );
  }
}

class BottomNavigationBarRecipe extends StatefulWidget {
  BottomNavigationBarRecipe({Key key, this.title}) : super(key: key);

  final String title;

  @override
  _BottomNavigationBarRecipeState createState() => _BottomNavigationBarRecipeState();
}

class _BottomNavigationBarRecipeState extends State<BottomNavigationBarRecipe> {

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Center(
        child: Text('Checkout BottomNavigationBar in action below'),
      ),
      bottomNavigationBar: BottomAppBar(
          child: Row(
            children: <Widget>[
              // Bottom that pops up from the bottom of the screen.
              IconButton(
                icon: Icon(Icons.menu),
                onPressed: () {
                  showModalBottomSheet<Null>(
                    context: context,
                    builder: (BuildContext context) => openBottomDrawer(),
                  );
                },
              ),
              IconButton(
                icon: Icon(Icons.search),
                onPressed: () {
                  Fluttertoast.showToast(msg: 'Clicked on Search menu action.');
                },
              ),
              IconButton(
                icon: const Icon(Icons.more_vert),
                onPressed: () {
                  Fluttertoast.showToast(msg: 'This is where overflow menu actions will go');
                },
              ),
            ],
          )),
    );
  }

  //This drawer is opened in modal bottom sheet
  Widget openBottomDrawer() {
    return Drawer(
      child: Column(
        children: const <Widget>[
          //Add menu item to edit
          const ListTile(
            leading: const Icon(Icons.mode_edit),
            title: const Text('Edit'),
          ),
          const ListTile(
            //Add menu item to add a new item
            leading: const Icon(Icons.add),
            title: const Text('Add'),
          ),
        ],
      ),
    );
  }
}

Source code repo: Recipe source code is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Flutter code recipe for AppBar widget

2019-02-02T23:33:00-05:00

AppBar

AppBar widget is the main widget in any Android app. It sits at the top of the application, and mostly controls major action items. In today's recipe, I'll show you how to design an AppBar for a phonebook style app. The AppBar will have a phonebook icon, a title saying 'Contacts' and action items in AppBar's always on area as well as in overflow area.

Target Audience: Beginner

Recipe: Implement a basic appBar with a title, actions, and an overflow dropdown menu.

Focus Widget: AppBar

Goal: AppBar displays an icon, title, action and overflow menu items. Clicking on action/overflow menu items displays status message.

Lets's go!

Step #1. Create AppBar inside Scaffold. backgroundColor is used for setting background color of the AppBar

return Scaffold(
      appBar: AppBar(
        backgroundColor: Colors.blue,
        ...
      ),
    );

Step #2. Add image Icon using leading attribute

return Scaffold(
      appBar: AppBar(
        ...
        leading: Icon(Icons.import_contacts),
        ...
      ),
    );

Step #3. Add AppBar's title

return Scaffold(
      appBar: AppBar(
        ...
        title: Text("Contacts"),
        ...
      ),
    );

Step #4. Add IconButton action item to send message.

return Scaffold(
      appBar: AppBar(
        ...
        actions: <Widget>[
          IconButton(
            icon: Icon(Icons.message),
            onPressed: () {
              clicked(context, "Message sent");
            },
          ),
        ],
      ),
    );

Step #5. Add overflow action item using PopupMenuButton

return Scaffold(
      appBar: AppBar(
        ...
        actions: <Widget>[
          ...
          PopupMenuButton(
            itemBuilder: (BuildContext context) {
              return [
                PopupMenuItem(child: IconButton(
                  icon: Icon(Icons.email),
                  onPressed: () {
                   clicked(context, "Email sent");
                  },
                ),),
              ];
            },
          )
        ],
      ),
    );

Step #6. Handle action item clicks

void clicked(BuildContext context, menu) {
    final scaffold = Scaffold.of(context);
    scaffold.showSnackBar(
      SnackBar(
        content: Text(menu),
        action: SnackBarAction(
            label: 'UNDO',
            onPressed: scaffold.hideCurrentSnackBar),
      ),
    );
}

Complete example code

import 'package:flutter/material.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Basic Appbar Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: BasicAppbarRecipe(title: 'Basic Appbar'),
    );
  }
}

class BasicAppbarRecipe extends StatefulWidget {
  BasicAppbarRecipe({Key key, this.title}) : super(key: key);

  final String title;

  @override
  _BasicAppbarRecipeState createState() => _BasicAppbarRecipeState();
}

class _BasicAppbarRecipeState extends State<BasicAppbarRecipe> {

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        backgroundColor: Colors.blue,
        //setting the icon for the AppBar
        leading: Icon(Icons.import_contacts),
        //setting title for the AppBar
        title: Text("Contacts"),
        actions: <Widget>[
          //Setting IconButton action item to send message
          IconButton(
            icon: Icon(Icons.message),
            onPressed: () {
              //Handling click on the action items
              clicked(context, "Message sent");
            },
          ),
          //Setting Overflow action items using PopupMenuButton
          PopupMenuButton(
            itemBuilder: (BuildContext context) {
              return [
                PopupMenuItem(child: IconButton(
                  icon: Icon(Icons.email),
                  onPressed: () {
                    clicked(context, "Email sent");
                  },
                ),),
              ];
            },
          )
        ],
      ),
    );
  }

  void clicked(BuildContext context, menu) {
    final scaffold = Scaffold.of(context);
    scaffold.showSnackBar(
      SnackBar(
        content: Text(menu),
        action: SnackBarAction(
            label: 'UNDO',
            onPressed: scaffold.hideCurrentSnackBar),
      ),
    );
  }
}

Source code repo: Recipe source code is available here

References:

https://docs.flutter.io/flutter/material/AppBar-class.html

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Flutter code recipe for AnimatedOpacity widget

2019-01-30T23:33:00-05:00

AnimatedOpacity

AnimatedOpacity widget is used to achieve a smooth transition from one UI element to another.

Target Audience: Beginner Recipe: Achieve a smooth animation when transitioning from one UI element to another.

Focus Widget: AnimatedOpacity

Goal: Fade in and out a blue rectangle on a click of button. Interface is super simple and will look like this:

Blue Rectangle animates when button is pressed:

Checkout AnimatedOpacity animation:

Lets's go!

We need three things to accomplish our goal of animating a blue rectangle. 1. Widget to animate: A blue rectangle

    Container(
        width: 100,
        height: 150,
        color: Colors.blue,
    );

StatefulWidget: A way to hold visibility state of rectangle. StatefulWidget has State object that can hold and update some data for app. State object's setState method helps to rebuild widget reflecting the updated state of the app data.

class AnimatedOpacityRecipe extends StatefulWidget {
  @override
  State<StatefulWidget> createState() => _AnimatedOpacityRecipeState();
}

The State object will have the flag about the rectangle widget's visibility state say _visible. _visible to true means that rectangle is visible or vice versa.

class _AnimatedOpacityRecipeState extends State<AnimatedOpacityRecipe> {
  bool _visible = true;

}

Method animatedOpacityWidget returns the AnimatedOpacity widget. duration property is to control the speed of animation. In this example, it takes 900 milliseconds to fade out the rectangle. This is important to show a smooth transition.

Widget animatedOpacityWidget() {
    return AnimatedOpacity(
      duration: Duration(milliseconds: 900),
      opacity: _visible ? 1 : 0,
      child: _blueRectangle(),
    );
  }

OutlineButton widget: A button to toggle fade in/out rectangle Button labeled 'Animate' to fade in/out rectangle. setState() method toggles the visibility flag for the rectangle widget. It forces Flutter to rebuilt AnimatedOpacity widget in accordance with new value of _visible flag.

...
OutlineButton(
  shape: new RoundedRectangleBorder(
    borderRadius: new BorderRadius.circular(8.0),
  ),
  child: Text("Press to Animate"),
  onPressed: () {
    setState(() => _visible = !_visible);
  },
)
...

Complete example code

import 'package:flutter/material.dart';

//starting the app
void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Cookbook',
      theme: ThemeData(
        // This is the theme of your application.
        primarySwatch: Colors.green,
      ),
      home: AnimatedOpacityRecipe(title: 'AnimatedOpacity Demo'),
    );
  }
}

class AnimatedOpacityRecipe extends StatefulWidget {
  final String title;

  AnimatedOpacityRecipe({Key key, this.title}) : super(key: key);
  @override
  State<StatefulWidget> createState() => _AnimatedOpacityRecipeState();
}

class _AnimatedOpacityRecipeState extends State<AnimatedOpacityRecipe> {
  bool _visible = true;

  Widget _blueRectangle() {
    return Container(
      width: 100,
      height: 150,
      color: Colors.blue,
    );
  }

  Widget animatedOpacityWidget() {
    return AnimatedOpacity(
      duration: Duration(milliseconds: 900),
      opacity: _visible ? 1 : 0,
      child: _blueRectangle(),
    );
  }
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title:Text(widget.title),
      ),
      body: buildDemoComponent(context),
    );
  }

  Widget buildDemoComponent(BuildContext context) {
    return Material(
      child: Padding(
        padding: EdgeInsets.all(8.0),
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            Padding(
              child: Text(
                  'Press button to see blue rectangle fade out and in'
              ),
              padding: EdgeInsets.all(20.0),
            ),
            animatedOpacityWidget(),
            OutlineButton(
              shape: new RoundedRectangleBorder(
                borderRadius: new BorderRadius.circular(8.0),
              ),
              child: Text("Press to Animate"),
              onPressed: () {
                //Toggles visibility of the rectangle
                setState(() => _visible = !_visible);
              },
            )
          ],
        ),
      ),
    );
  }
}

Source code repo: Recipe source code is available here

References:

https://flutter.io/docs/cookbook/animation/opacity-animation.html
https://docs.flutter.io/flutter/widgets/Opacity-class.html

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Flutter code recipe for Hero animation

2019-01-30T23:33:00-05:00

Animation Hero

Hero animation is a useful transition when items are listed with small icons. Tapping on icons can open in another page with enlarged icon widget.

Target Audience: Beginner Recipe: Hero animation to transition a list icon into an enlarged view on another detail page.

Focus Widget: Hero Widget

Hero(
    tag: 'hero-rectangle',
    child: _blueDetailRectangle(),
),

Goal: Animate and enlarge list item icon using Hero widget. Tapping on a list item icon, opens up the item in another page with enlarged icon.

Checkout Hero animation:

Lets's go!

We need these things to accomplish our goal. 1. List item along with Icon: I'll be using a rectangle widget for icon.

Icon widget in list item at first page:

    Widget _blueIconRectangle() {
        return Container(
          width: 50,
          height: 50,
          color: Colors.blue,
    );
  }

Hero widget in list:

Widget buildWidget(BuildContext context) {
    return Center(
        ...
              child: Hero(
                tag: 'hero-rectangle',
                child: _blueIconRectangle(),
              ),
              onTap: () => _gotoDetailsPage(context),

        ...
  }

Enlarged icon to display on the second page.

  Widget _blueDetailRectangle() {
    return Container(
      width: 200,
      height: 200,
      color: Colors.blue,
    );
  }

Using enlarged icon in second page:

void _gotoDetailsPage(BuildContext context) {
    Navigator.of(context).push(MaterialPageRoute(
      builder: (ctx) => Scaffold(
            body: Center(
              child: Column(
                mainAxisAlignment: MainAxisAlignment.center,
                children: <Widget>[
                  Hero(
                    tag: 'hero-rectangle',
                    child: _blueDetailRectangle(),
                  ),
                  Text(
                      'This is where you can see details about the list item tapped at previous page.'),
                ],
              ),
            ),
          ),
    ));
  }

Notice that Navigator.of(context).push() is needed to navigate to second page from first page using the same tag.

Making sure both widgets in step #1 and step #2 have same tag. Hero transitions use the same tag to identify the start and destination widgets.

Complete example code

import 'package:flutter/material.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.green,
      ),
      home: HeroAnimationRecipe(title: 'Hero Animation'),
    );
  }
}

class HeroAnimationRecipe extends StatefulWidget {
  HeroAnimationRecipe({Key key, this.title}) : super(key: key);
  final String title;

  @override
  _HeroAnimationRecipeState createState() => _HeroAnimationRecipeState();
}

class _HeroAnimationRecipeState extends State<HeroAnimationRecipe> {

  Widget _blueIconRectangle() {
    return Container(
      width: 50,
      height: 50,
      color: Colors.blue,
    );
  }

  Widget _blueDetailRectangle() {
    return Container(
      width: 200,
      height: 200,
      color: Colors.blue,
    );
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: buildDemoWidget(context),
    );
  }

  Widget buildDemoWidget(BuildContext context) {
    return Center(
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: <Widget>[
          SizedBox(
            height: 20.0,
          ),
          ListTile(
            leading: GestureDetector(
              child: Hero(
                tag: 'hero-rectangle',
                child: _blueIconRectangle(),
              ),
              onTap: () => _gotoDetailsPage(context),
            ),
            title: Text('Tap on the icon to view hero animation transition.'),
          ),
        ],
      ),
    );
  }

  void _gotoDetailsPage(BuildContext context) {
    Navigator.of(context).push(MaterialPageRoute(
      builder: (ctx) => Scaffold(
        body: Center(
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: <Widget>[
              Hero(
                tag: 'hero-rectangle',
                child: _blueDetailRectangle(),
              ),
              Text(
                  'This is where you can see details about the list item tapped at previous page.'),
            ],
          ),
        ),
      ),
    ));
  }
}

Source code repo: Recipe source code is available here

References:

Happy cooking with Flutter :)

Liked the article ? Couldn't find a topic of your interest ? Please leave comments or email me about topics you would like me to write ! BTW I love cupcakes and coffee both :)

Getting started with developing Android apps in Kotlin

2017-06-18T15:55:00-04:00

Creating Kotlin Project in Android Studio (>=3)

In Android Studio 3 and higher, there's an option to select to create projects supporting Kolin. It's super simple to start writing your app from scratch in Kotlin. Here are screenshots to demo creating a Navigation Drawer based app in Kotlin:

Creating New Project in Android Studio Don't forget to check Kotlin support checkbox.

Choosing MainActivity I'm using Navigation Drawer activity as MainActivity for this sample app.

build.gradle build.gradle will automatically add support for Kotlin language and other related plugins/libraries:

MainActivity MainActivity will be generated in Kotlin automatically. This is how it would look like:

Running First Kotlin App This is how running Kotlin sample on device would look like:

Facts about Kotlin

Kotlin's runtime library file size is about 859KB (as of version 1.1..2-5), which doesn't increase final APK size significantly.
There's no visual difference between Kotlin vs Java applications on Android platform, because Kotlin compiler produces byte-code.

Interested in checking out source code for this demo sample app ? Find it on Github References: Kotlin language's official site

Android Studio Tips & Tricks Series

2017-04-13T13:06:00-04:00

Tips And Tricks

How to get SHA1 fingerprint for digitally signed APK

How to get SHA1 fingerprint for digitally signed APK

2017-04-13T13:06:00-04:00

How to get SHA1 fingerprint for digitally signed APK

Open terminal in Android Studio
Run Keytool utility to get SHA1 for your APK:

keytool -exportcert -alias <your_alias> -keystore <path-to-keystore> -list -v

Automating Android App publishing to Play Store using Jenkins

2017-02-23T12:02:00-05:00

Introduction

This article describes the journey I took from setting up Jenkins to automate publishing Android APKs to Google Play Publishing portal and useful notes that I collected along the way. I set up Jenkins-2.46 on Mac OSX 10.12.3.

Download Package

You can download “.pkg” file from here

Complete Installation

Follow the instructions to complete installation.

Note: You’ll be asked to enter an additional password like below to ensure the security:

Choosing Plugins

You can go with default plugins unless you know what plugins you want to install. I'll cover other plugins, if needed as their need arises.

Starting Jenkins

Once installation is complete, you can type http://localhost:8080 in your browser to start jenkins server. It’ll ask for temporary password it created at : /Users/Shared/Jenkins/Home/secrets/initialAdminPassword

This is how it will look like:

Note: Unless you’ve created an admin user explicitly, you can login as administrator using username “admin” and password created in “/Users/Shared/Jenkins/Home/secrets/initialAdminPassword” file.

Click on “Start Jenkins” to start creating jobs on Jenkins to automate project building and publishing.

Setting up Job to Build Android project

Create Jenkins Job

Create a free-style project.
Add Repository in Source Code Management section. You will have to provide credentials to Jenkins to access source code repository.
Add build specific configuration in Build section. I'll be using shell script to build my gradle based project.

Note: If you're running into source code repo access issues, then you may want to add credentials like this:

Uploading APK to Play Store

Setup

You'll need Google Play Android Publisher Plugin plugin to publish APKs automatically from Jenkins.
Navigate to localhost:8080 in your browser to get to Jenkins. Click on Manage Jenkins --> Manage Plugins. Look for 'Google Play Android Publisher Plugin' by typing it in search box and install. You'll need to add service account to Jenkins as well. Refer to link for detailed process).
You'll need to enable API access from Jenkins. So, you have to be owner of your Google Play Publisher account
Its important to know that you must have pre-existing app in Play Store already before you could upload another incremental update via Jenkins.
Create Service account at Play Store publishing portal under 'API Access' category at left. It'll take you to Google project console. This is where, you'll create 'JSON' or 'p12' key to enable integration between Jenkins and Play Store publishing. Keep this key safe since you'll need this to enable Jenkins account to access Play store publishing. Also, Don't forget to grant 'Release Manager' permissions to this service account in Play store Publishing portal.
Go back to Jenkins, and create credentials to access Play Store. This is where you'll need to provide JSON key that you created in step above.

Here is pretty good explanation of process to setup your accounts.

Note 1: You can use following command on terminal to reset jenkins user password, if run into password related issues:

sudo passwd jenkins

Note 2: Jenkins will need its own installation of Android sdk. Don't forget to make sure that sdk installation has license directory. If its not available, then copy it from you other sdk instaltion to here at first level. Check this link for details.

Configuring Job 1. Add post-build action: "Upload Android APK to Google Play"

Fill-in the path or pattern to APK created locally. In my case, its **/*-release.apk. Also, add languages supprted and add roll-out percentage if its being pushed in production channel. I'm publishing to alpha channel.

And you're done !

For more details about configuring uploading job refer to this link.

Extra Credits: EnvInject Plugin can be used to supply APK signing password to Jenkins job. Checkout this StackOverflow answer on how to set it up.

Creating Sub MenuItems for FAB (Floating Action Button)

2017-02-15T11:24:00-05:00

Final Outcome

Our target to integrate FAB into an existing Android App and creating submenus. Settings icon is used as FAB. Clicking on it will open its submenus: Save, Edit and Photo. Clicking on X will close submenus and Settings icon will re-appear.

This is how main screen will look after FAB integrated into it.

Clicking on Settings icon will open sub menus:

Create Android Studio Project

Step#1: Create New Project in Android Studio:

Step#2: Choose Blank Activity:

Step#3: This how your project would look like :

Preparation

Step#1: Assets: I need few assets to be used as FAB submenu icons. I used Android Studio’s built-in tool to generate Vector Assets. You can access this tool right clicking on app module → Click New → Click on Vector Assets

Step#2: Configuration: I’ll be using cardView component to display description for sub menu items. Here’s how you can add it as a dependency in your build.gradle: compile 'com.android.support:cardview-v7:25.1.0'

XML Layout

Step#1: Create a new layout file to contains FAB and its sub menu items.

I named it as layout_fab_submenu.xml. It’s a FrameLayout.

I chose FrameLayout because I wanted a screen floating atop of existing screen and a holder for all FAB menu items. Don’t forget to set the top margin to android:layout_marginTop="?attr/actionBarSize" to avoid Actionbar overlapping.

<FrameLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/fabFrame"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_marginTop="?attr/actionBarSize"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:orientation="vertical">

    .....
</FrameLayout>

Step#2: Layout for FAB SubMenu items

Now, I want to create one LinearLayout for each FAB. Since I want all of the FAB items to be at bottom right corner of screen, so I will use android:layout_gravity=bottom|end. Every sub menu will have its own LinearLayout like following. Each LinearLayout has one CardView to hold TextView for explaining FAB's purpose and one android.support.design.widget.FloatingActionButton next to it.

<LinearLayout
        android:id="@+id/layoutFabSave"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:gravity="center_vertical"
        android:layout_gravity="bottom|end"
        android:layout_marginRight="8dp"
        android:layout_marginBottom="120dp"
        android:layout_marginEnd="8dp"
        android:orientation="horizontal">

        <android.support.v7.widget.CardView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            app:cardBackgroundColor="@color/cardview_light_background"
            app:cardCornerRadius="@dimen/cardCornerRadius"
            app:cardElevation="@dimen/cardElevation"
            app:cardUseCompatPadding="true" >
            <TextView
                android:id="@+id/cvtSave"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/save"
                android:textAppearance="?android:attr/textAppearanceSmall"
                android:textStyle="bold"
                android:paddingRight="@dimen/cardview_horizontal_padding"
                android:paddingLeft="@dimen/cardview_horizontal_padding"
                android:paddingBottom="@dimen/cardview_vertical_padding"
                android:paddingTop="@dimen/cardview_vertical_padding" />
        </android.support.v7.widget.CardView>

        <android.support.design.widget.FloatingActionButton
            android:id="@+id/fabSave"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:src="@drawable/ic_save_black_24dp"
            app:backgroundTint="@android:color/holo_green_light"
            app:fabSize="mini" />

    </LinearLayout>

Lets check out More Code

In order to support FAB opening and closing, you would need to write two methods. One is to make sub menus visible, and other is to hide sub menus and only show main FAB which is Settings icon is our case. When Settings FAB expands, it turns into 'X' to give option to be able to close expanded sub menus. These are the two methods you would need:

//closes FAB submenus
    private void closeSubMenusFab(){
        layoutFabSave.setVisibility(View.INVISIBLE);
        layoutFabEdit.setVisibility(View.INVISIBLE);
        layoutFabPhoto.setVisibility(View.INVISIBLE);
        fabSettings.setImageResource(R.drawable.ic_settings_black_24dp);
        fabExpanded = false;
    }

    //Opens FAB submenus
    private void openSubMenusFab(){
        layoutFabSave.setVisibility(View.VISIBLE);
        layoutFabEdit.setVisibility(View.VISIBLE);
        layoutFabPhoto.setVisibility(View.VISIBLE);
        //Change settings icon to 'X' icon
        fabSettings.setImageResource(R.drawable.ic_close_black_24dp);
        fabExpanded = true;
    }

Now, its time to hook them up in the main code to make it functional. Lets start with onCreate() method:

public class MainActivity extends AppCompatActivity {

    //boolean flag to know if main FAB is in open or closed state.
    private boolean fabExpanded = false;
    private FloatingActionButton fabSettings;

    //Linear layout holding the Save submenu
    private LinearLayout layoutFabSave;

    //Linear layout holding the Edit submenu
    private LinearLayout layoutFabEdit;
    private LinearLayout layoutFabPhoto;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

        fabSettings = (FloatingActionButton) this.findViewById(R.id.fabSetting);

        layoutFabSave = (LinearLayout) this.findViewById(R.id.layoutFabSave);
        layoutFabEdit = (LinearLayout) this.findViewById(R.id.layoutFabEdit);
        layoutFabPhoto = (LinearLayout) this.findViewById(R.id.layoutFabPhoto);

        //When main Fab (Settings) is clicked, it expands if not expanded already.
        //Collapses if main FAB was open already.
        //This gives FAB (Settings) open/close behavior
        fabSettings.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if (fabExpanded == true){
                    closeSubMenusFab();
                } else {
                    openSubMenusFab();
                }
            }
        });

        //Only main FAB is visible in the beginning
        closeSubMenusFab();
    }

    ....
}

Congratulations!

Yay ! You got FAB integrated along with sub menu in less than 5 minutes. Its time to celebrate :)

Source code is available at Github

Android WebViewOverlay Widget

2017-01-09T11:16:00-05:00

Motivation

I needed a widget that can load a url in WebView in a full-screen closable overlay/modal. I wanted to re-use this new, shiny widget in my other projects as well. So, I decided to upload WebViewOverlay library in a central artifact repository. I chose JCenter because its one of the largest artifact repository for Java and Android libraries and has good integration with Android Studio IDE. If you're interested in learning how did I publish Android libary to JCenter, then this post will be helpful for you.

Introduction

This article describes how WebViewOverlay Widget can be integrated to your Android App in few minutes. Integrating WebViewOverlay widget in your app is as simple as adding following line in your project's build.gradle:

compile 'org.ptyagicodecamp:WebViewOverlay:1.0.2'

WebViewOverlay Widget

WebViewOverlay widget loads a WebView widget in a full screen pop-up or modal. It has option to close it by clicking on top-right corner 'x'

API

There're two APIs to load WebView either in full-screen mode or in a dialog with a custom title.

Full Screen Overlay

void loadWebViewOverlay(String urlToBeLoaded, HashMap<String, String> params);

Full Screen Overlay With Custom Title

void loadWebViewOverlay(String urlToBeLoaded, HashMap<String, String> params, String popupTitle);

Integration

In Android Studio, it can be added to your project by adding following in build.gradle

compile 'org.ptyagicodecamp:WebViewOverlay:1.0.2'

Initialization

WebViewOverlay widget can be initialized in Activity or BaseActivity's onCreate() method.

WebViewOverlay webViewOverlay;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    webViewOverlay = new WebViewOverlay(this);
}

Usage

After initializing widget, it can simply be used by calling either of the API. Here's examples to demonstrate both APIs:

public void openWebViewOverlay(View view) {
    String url = "https://ptyagicodecamp.github.io";
    webViewOverlay.loadWebViewOverlay(url, null);
}

public void openWebViewOverlayWithTitle(View view) {
    String url = "https://ptyagicodecamp.github.io";
    webViewOverlay.loadWebViewOverlay(url, null, "WebViewOverlay Demo");
}

If you're interested in checking out source code, then its available here at Github

How did I publish Android Library to JCenter from Android Studio

2017-01-07T17:27:00-05:00

Introduction

JCenter is a Maven Repository or file server hosted by Bintray for Android libraries. It’s a default repository for Android Studio. To demonstrate the process of publishing an OpenSource Android library, I'm using WebViewOverlay widget library for example. After uploading to JCenter artifact repo, WebViewOverlay widget can be dropped-in to your project like this:

compile 'org.ptyagicodecamp:WebViewOverlay:1.0.2'

Uploading Android library (in aar format) to Bintray

Create log-in at Bintray. Scroll down to register for an open-source project.
Create a new repo:
Fill-in all required information and click "create repo". It'll redirect to "package" screen.
Click on “Create Package”. Fill in your package name and click on "Add New Package":
It'll take you to enter package details. Fill-in details and click on "Create Package" at the bottom.

And you’re Done with registering your Maven repository on Bintray !

Note: Link your Github account from Bintray, if you want to upload library from build.gradle (Android Studio). You can do this by going into your repository on Bintray and selecting "Import from Github” option. It’ll guide you through with rest of the steps.

Setting up Android Studio Project

Create a new project in Android Studio.
Module WebViewOverlay contains all the library code and module app has sample app to demonstrate the usage of library. Make sure that you name module same as of artifact name configured at Bintray. WebViewOverlay in this example. Refer to WebViewOverlay at Github for source code.
Setup Android Studio project to be able to publish library to jcenter() Maven repo, and add Bintray plugin to project’s build.gradle. Root level build.gradle will look like this:

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.2.3'
        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.4'
        classpath 'com.github.dcendents:android-maven-gradle-plugin:1.4.1'
    }
}

allprojects {
    repositories {
        jcenter()
    }
}

Update Bintray related credentials in local.properties like this:

bintray.user=YOUR_BINTRAY_USERNAME
bintray.apikey=YOUR_BINTRAY_API_KEY

Note: Look for API KEY in your Profile section on Bintray.

Add following in library module’s build.gradle. In this case build.gradle of WebOverlay:

apply plugin: 'com.android.library'

ext {
    bintrayRepo = 'WebViewOverlay'
    bintrayName = 'WebViewOverlay'

    publishedGroupId = 'org.ptyagicodecamp'
    libraryName = 'WebViewOverlay'
    artifact = 'WebViewOverlay'

    libraryDescription = 'A widget to load WebView as an Overlay.'

    siteUrl = 'https://github.com/ptyagicodecamp/webview-overlay'
    gitUrl = 'https://github.com/ptyagicodecamp/webview-overlay.git'

    libraryVersion = '1.0.0'

    developerId = 'developerId'
    developerName = 'Developer Name'
    developerEmail = 'developer@email.com'

    licenseName = 'The Apache Software License, Version 2.0'
    licenseUrl = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
    allLicenses = ["Apache-2.0"]
}

Refer to this build.gradle

You would need to add these scripts in order to publish libraries to Bintray:

//Add these lines to publish library to bintray. This is the readymade scripts made by github user nuuneoi to make uploading to bintray easy.
//Place it at the end of the file
apply from: 'https://raw.githubusercontent.com/nuuneoi/JCenter/master/installv1.gradle'
apply from: 'https://raw.githubusercontent.com/nuuneoi/JCenter/master/bintrayv1.gradle'

That's all you ve to do in order to configure you Android Studio project.

Uploading to Bintray:

CD to Root of Android Studio Project, and run these commands:

gradlew install
gradlew bintrayUpload

That’s it ! your artifact will be uploaded to Bintray.

Link to JCenter

Your package needs to be linked to JCenter to be able to be resolved.
It'll take couple of hours to get request approved. Once approved, you'll see you package like this:

Note: You will have to wait for couple of hours before it'll be synced on JCenter. You can check if its available by going to "http://jcenter.bintray.com/"

Start using your hosted library:

Now you can reference WebViewOverlay library from your project's build.gradle like this:

compile 'org.ptyagicodecamp:WebViewOverlay:1.0.0'

References:

I followed this tutorial to get me setup at Bintray.

Automatic Android APK Signing

2016-12-20T12:51:00-05:00

Declaring Signing credentials

Never put your signing apk credentials in github or any public sharable place. Always put them in a non-committable file. I'll be using local gradle installations's gradle.properties to store signing creds. It sits at root level of your project. Alternately, you can also use /.gradle/.gradle.properties.

Declaring release apk credentials

RELEASE_KEYSTORE_FILE={path to your release keystore}
RELEASE_KEYSTORE_PASSWORD=*****
RELEASE_KEYSTORE_ALIAS=*****

Declaring debug apk credentials

DEBUG_KEYSTORE_FILE={path to your debug keystore}
DEBUG_KEYSTORE_PASSWORD=*****
DEBUG_KEYSTORE_ALIAS=*****

Note: There is no quotes around file path, passwords and alias.

Loading variables from gradle.properties into build.gradle

Properties properties = new Properties()
properties.load(project.rootProject.file('gradle.properties').newDataInputStream())
def RELEASE_KEYSTORE_FILE = properties.getProperty('RELEASE_KEYSTORE_FILE')
def RELEASE_KEYSTORE_PASSWORD = properties.getProperty('RELEASE_KEYSTORE_PASSWORD')
def RELEASE_KEYSTORE_ALIAS = properties.getProperty('RELEASE_KEYSTORE_ALIAS')

def DEBUG_KEYSTORE_FILE = properties.getProperty('DEBUG_KEYSTORE_FILE')
def DEBUG_KEYSTORE_PASSWORD = properties.getProperty('DEBUG_KEYSTORE_PASSWORD')
def DEBUG_KEYSTORE_ALIAS = properties.getProperty('DEBUG_KEYSTORE_ALIAS')

Defining Signing config in `build.gradle`

signingConfigs {
        debug {
            storeFile file(new File(DEBUG_KEYSTORE_FILE))
            storePassword DEBUG_KEYSTORE_PASSWORD
            keyAlias DEBUG_KEY_ALIAS
            keyPassword DEBUG_KEY_PASSWORD
        }

        release {
            storeFile file(new File(RELEASE_KEYSTORE_FILE))
            storePassword RELEASE_KEYSTORE_PASSWORD
            keyAlias RELEASE_KEY_ALIAS
            keyPassword RELEASE_KEY_PASSWORD
        }
    }

Note: Order of defining buildTypes block and signingConfigs block is very important. signingConfigs comes before buildTypes block.

Putting All together

Full signing configuration in build.gradle will look like this:

apply plugin: 'com.android.application'

android {
    compileSdkVersion 22
    buildToolsVersion "22.0.1"

    defaultConfig {
        applicationId "com.myawesomeproject.id"
        minSdkVersion 14
        targetSdkVersion 24
        versionCode 1
        versionName "1.1"
    }

    signingConfigs {
        debug {
            storeFile file(new File(DEBUG_KEYSTORE_FILE))
            storePassword DEBUG_KEYSTORE_PASSWORD
            keyAlias DEBUG_KEY_ALIAS
            keyPassword DEBUG_KEY_PASSWORD
        }

        release {
            storeFile file(new File(RELEASE_KEYSTORE_FILE))
            storePassword RELEASE_KEYSTORE_PASSWORD
            keyAlias RELEASE_KEY_ALIAS
            keyPassword RELEASE_KEY_PASSWORD
        }
    }

    buildTypes {
        debug {
            signingConfig signingConfigs.debug
            minifyEnabled false
        }

        release {
            signingConfig signingConfigs.release
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
} //closing android block


dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
}

WebViewHelper library

2016-12-16T15:06:00-05:00

A little about WebView widgets:

Webview widget is used to display HTML contents in an Android app. HTML contents can be rendered in a TextView widget using Html.fromHtml() method to parse very basic text. So why do we need WebView widget ? WebView widget is capable of handling more advanced HTML tags, Javascript and CSS, which gives a native feel to HTML contents right in your app. But this doesn't come for free. WebViews are more memory intensive when compared to TextView widget.

Background:

Pre Android 4.4, WebView was powered by WebKit. Starting Android 4.4, it’s powered by Chromium. Starting Android 5.0, WebView is distributed through Google Play Store. Starting Android 7.0, WebView uses Chrome browser app or System WebView app when Chrome browser is disabled.

Downside of newer implementation starting Android 5.0: Since System WebView implementation is distributed through Play Store and no more bundled in Android OS, its challenging for OEMs to keep their implementation of WebView in sync with Play Store’s System WebView. The two can go out of sync very quickly.

Behaviors:

Any links embedded in a WebView widget will open in a WebView in Android 5.0 and over.
On Android 4.4 and below, links embedded in a WebView will open in a Web Browser rather than in a WebView widget
By default, javascript is disabled in WebView widget. It can be turned on by getSettings().setJavaScriptEnabled(true). I’ve created convenience class WebViewHelper around android.webkit.WebView class features.

Using from Android Studio:

Add following in your project's build.gradle under dependencies block.

compile 'org.ptyagicodecamp:webview-android:0.0.2'

How to use `WebViewHelper` class ?

Initializing

You would need to pass reference to WebView widget into WebViewHelper like this:

WebViewHelper webViewHelper;
....

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        webView = (WebView) findViewById(R.id.webView);
        //initialize WebViewHelper
        webViewHelper = new WebViewHelper(webView);
    }

Using library

public void loadUrl(View view) {
        webViewHelper.loadUrl("https://ptyagicodecamp.github.io/");
    }

    public void loadData(View view) {
        webViewHelper.loadData("<html><a href=\"https://ptyagicodecamp.github.io/\">Click Here to visit my Blog</html>");
    }

    public void toggleJavaScript(View view) {

        if (((ToggleButton)view).isChecked()) {
            webViewHelper.enableJS();
            Toast.makeText(this, "Javascript is enabled", Toast.LENGTH_LONG).show();
        } else {
            webViewHelper.disableJS();
            Toast.makeText(this, "Javascript is disabled", Toast.LENGTH_LONG).show();
        }
    }

Source code is available here

My take on Pelican and Github pages from a beginner's perspective

2016-12-08T10:20:00-05:00

Setting up environment:

First we need a pacakge manager to install necessery tools and packages. I chose Homebrew. Install Homebrew package manager and other needed tools for Mac by pasting this command in terminal: /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" brew install wget
Now, use Homebrew to install python, pip and other related tools. As time of this writing, it will install Python 2.7.12. brew install python
Setup vitutalenv tool to keep python installations separate in their own sandbox: pip install virtualenv
Creating virtualenv for pelican mkdir -p ~/virtualenvs cd ~/virtualenvs virtualenv pelican cd pelican source bin/activate
Install pelican: pip install pelican
Install markdown package: pip install pelican markdown

Setting up github repos:

One repo for source code for blog generator: ptyagicodecamp.github.io-src
One repo for generated html blog contents: ptyagicodecamp.github.io

Setting up Blog with Pelican:

Clone github source repo into your local working directory:

git clone https://github.com/ptyagicodecamp/ptyagicodecamp.github.io-src.git githubpages
cd githubpages

Create output directory inside githubpages directory to hold generated html pages to add it as a git submodule: git submodule add https://github.com/ptyagicodecamp/ptyagicodecamp.github.io.git output
Setup pelican :

pelican-quickstart
> Where do you want to create your new web site? [.]
> What will be the title of this web site? **Title of your blog**   
> Who will be the author of this web site? **your name**
> What will be the default language of this web site? [en]
> Do you want to specify a URL prefix? e.g., http://example.com   (Y/n) Y
> What is your URL prefix? (see above example; no trailing slash) http://username.github.io
> Do you want to enable article pagination? (Y/n)
> How many articles per page do you want? [10]
> What is your time zone? [Europe/Paris]    America/Mazatlan
> Do you want to generate a Fabfile/Makefile to automate generation and publishing? (Y/n) Y
> Do you want an auto-reload & simpleHTTP script to assist with theme and site development? (Y/n) Y
> Do you want to upload your website using FTP? (y/N) N
> Do you want to upload your website using SSH? (y/N) N
> Do you want to upload your website using Dropbox? (y/N) N
> Do you want to upload your website using S3? (y/N) N
> Do you want to upload your website using Rackspace Cloud Files? (y/N) N
> Do you want to upload your website using GitHub Pages? (y/N) Y
> Is this your personal page (username.github.io)? (y/N) Y
Error: [Errno 17] File exists: '~/githubpages/content'
Error: [Errno 17] File exists: '~/githubpages/output'
Done. Your new project is available at ~/githubpages

Note: Make DELETE_OUTPUT_DIRECTORY = False in publishconf.py to NOT delete output dir, since its a submodule.

Writing your first blog post:

Don't forget to install Markdown package: pip install Markdown. Also, don’t overlook that “.md” files needs meta-data at the beginning of file. Failing to do so, would give error that “NameTile” is failing. Meta data looks like this:

Title: My first title
Date: 2016-12-08 10:20
Modified: 2016-12-08 19:30
Category: Python
Tags: pelican, publishing

Now, write your first blog post by typing in terminal(or your faviorite editor) : vi content/<post-name>.md

Note: you're not required to use '.md' formatting, you can also use .rst formats too.

Build, Commit and Push posts :

Note: if you run into issue that pelicanconf.py doesn't exist, its because you may not have python environment loaded. You would need to execute this on terminal re-activate environment: source ~/virtualenvs/pelican/bin/activate

To generate HTML contents and start local webserver, type this on terminal: 'make html && make serve`
Generate website using: make publish
Committing to Github: At this point you can add all contents to github. To add submodule in output directory:

cd  output
git add .
git commit -m “Adding my contents”
git push -u origin master
cd ..
echo “*.pyc” >> .gitignore #you can also add this by manually editing .gitignore file
git add .
git commit -m “first commit”
git push -u origin master

Visting your Brand new Blog

You can visit your blog at https://username.github.io

Script to publish and push to github repo automatically:

I created publish-n-push.sh script to automate generating html contents and pushing everything to github:

echo "publising changes..."
make html && make publish
echo "pushing code to source repo..."
git add .
git commit -m "$1"
git push origin master
echo "pushing generated website to github"
cd output
git add .
git commit -m "$1"
git push origin master
cd ..

Using this script:

cd githubpages
./publish-n-push.sh "commit-message"

References

Here's wonderful tutorial about Markdown syntax
I refered this tutorial as a reference.

tech&Life

AI Agents at Two Speeds: ReAct for Simple Tasks, Deep Agents for Complex Work

AI Agents at Two Speeds: ReAct for Simple Tasks, Deep Agents for Complex Work

LangChain ReAct approach

Deep Agent approach

Difference visualization

Evaluation strategy

GitHub Code Repos

Decision guide

Final recommendation

Source notes

DORA is Dead: Why 2026 Demands "AI Attribution Layers" in the SDLC

DORA is Dead: Why 2026 Demands "AI Attribution Layers" in the SDLC

The Goodhart’s Law of AI

Why Optimizing for "Velocity" Leads to "Garbage In, Garbage Out"

Defining the AI Attribution Layer

The Digital Signature for the Modern SDLC

The Seniority Divide

Knowledge Retention as a Strategic Risk

The 2026 Playbook

Actionable Steps for Engineering Directors

1. Mandatory PR Metadata Tags

2. Risk-Weighted Review Pipelines

3. The Value-to-Churn Ratio (VCR)

Conclusion: Orchestration is the New Leadership

How Engineering Leaders Can Raise Internal Comms Quality with Anthropic Skills

How Engineering Leaders Can Raise Internal Comms Quality with Anthropic Skills

The Job-to-Be-Done

What the internal-comms Skill Is, and Isn’t

Five Playbooks to Try This Week

1. Weekly engineering 3P for execs

2. Post-incident executive summary

3. “Why we’re pausing initiative X”

4. Org newsletter blurb

5. Cross-team FAQ after a platform migration

The Rollout Recipe for Leaders

Risks and Hygiene

Try Tomorrow

References

The Paper Architect: Why Writing is the Highest-Leverage Mental Software You’re Not Updating

The Paper Architect: Why Writing is the Highest-Leverage Mental Software You’re Not Updating

1. The Research Foundation: The Biology of the Written Word

The Pennebaker Effect: Writing as Medicine

The Science of Gratitude and the Reward System

Cognitive Offloading and the Zeigarnik Effect

2. The Three-Pillar Framework

Pillar I: The Emotional Release (Expressive Writing)

Pillar II: The Numbness Antidote (Gratitude Writing)

Pillar III: The Conflict Resolver (Iterative Reflection)

3. Why the Hand-to-Brain Connection Matters

4. The Architecture of a New Life

Your 7-Day "Paper Architect" Challenge

Beyond the "Job Apocalypse": How AI is Fueling a Net-Positive Labor Revolution

Beyond the "Job Apocalypse": How AI is Fueling a Net-Positive Labor Revolution

1. The Refactoring of Labor: Replacing Tasks, Not People

2. The New Workforce Titans: A Net-Positive Reality

3. Productivity as a Growth Engine

4. The "Rehire" Phenomenon: The Empathy Gap

5. The Human Element & The Wage Premium

Key Takeaways

How to embed Mermaid Diagrams in Pelican generated Blog Post

How to embed Mermaid Diagrams in Pelican generated Blog Post

Import mermaid library

Wrap mermaid code in <pre> tag

Everything all together!

What makes Scrumban an effective Agile framework

What is Scrumban

What is Scrum

What is Kanban?

What is Scrumban?

Why Scrumban is Better

Flexibility and Adaptability

Improved Workflow Management

Better Team Collaboration and Efficiency

Scrum vs Kanban vs Scrumban

Conclusion

References

Creating Effective Tickets to get work done

Creating Effective Tickets

What is an Effective Ticket?

What the `internal-comms` Skill Is, and Isn’t

Import `mermaid` library

Wrap `mermaid` code in `<pre>` tag