Android Mad - Development Guide for Mobile App Development

Google Play Console now requires package name verification for all Android developers

2026-04-15T00:59:00.002+05:30

Google Play Console Now Requires Package Name Verification

Android development

Google has rolled out a major update to the Play Console — a mandatory package name verification system that changes how developers publish and manage apps on the Play Store. If you're building for Android, here's everything you need to know.

What changed

What is package name verification?

Package name verification is a new security requirement where developers must prove ownership of their app's package name before publishing a new app, releasing updates to existing apps, or managing apps within the Play Console.

In short: Google now verifies that the person uploading or updating an app is the legitimate owner of that app's package identity — not just someone who happens to know the package name.

Why it matters

Google's goals with this update

🛡️

Prevent fake apps

Stops bad actors from misusing or impersonating package names from legitimate apps.

🔒

Strengthen platform security

Ensures only authorized developers can manage apps tied to a specific package name.

✅

Protect genuine developers

Reduces the risk of app hijacking and protects the hard work of original creators.

Action required

What developers should do right now

To avoid any interruptions in publishing or updates, complete these steps as soon as possible:

1 Log in to your Google Play Console
2 Navigate to your app's dashboard
3 Look for the Package Name Verification section
4 Complete all required verification steps
5 Ensure any documentation requested is accurate and up to date

⚠️ If you skip verification, you may face:

Inability to publish new apps
Updates being blocked or delayed
Potential account or app restrictions

Best practices

Pro tips going forward

Always use a unique and consistent package name across releases

Keep documentation of app ownership on hand

Avoid package names that closely resemble popular apps

Complete verification early — don't wait until a release deadline

The bottom line

This update is a meaningful step toward a more trustworthy Play Store. While it adds a step to the publishing workflow, it ultimately benefits everyone by reducing fraud and protecting legitimate developers. Stay on top of Play Console announcements so you're never caught off guard by future policy changes.

Google Antigravity Tutorial: Build Real Applications with AI Agents

2026-04-04T14:57:00.004+05:30

AI is changing how software is built. Google Antigravity introduces a powerful shift where developers no longer write everything manually—instead, they manage intelligent AI agents that plan, code, test, and execute tasks.

This is a hands-on, real-world tutorial that will take you from beginner to advanced usage, including workflows, prompts, debugging, and building an actual project.

📌 Table of Contents

What is Google Antigravity?
Core Concepts You Must Understand
Setup & Installation
Interface Deep Dive
How AI Agents Work
Your First Project (Step-by-Step)
Advanced Features
Best Prompts for Better Results
Debugging & Optimization
Real-World Use Cases
Limitations & Best Practices

🌌 What is Google Antigravity?

Google Antigravity is an AI-driven development platform that uses autonomous agents to perform coding tasks. Instead of writing code line-by-line, you define goals, and AI agents execute them.

It combines:

AI reasoning
Code generation
Execution environment
Browser automation

🧠 Core Concepts You Must Understand

1. AI Agents

Agents are intelligent workers that can:

Understand tasks
Break them into steps
Execute code
Fix errors automatically

2. Tasks

A task is simply a goal you assign, like:

Create a blog website with login system

3. Artifacts

Artifacts are outputs generated by agents:

Code files
Logs
Plans
Screenshots

4. Mission Control

A dashboard where you manage multiple agents working simultaneously.

⚙️ Setup & Installation

Step 1: Requirements

Google account
Chrome browser
Minimum 8GB RAM (recommended)

Step 2: Install

Download and install Antigravity from the official platform.

Step 3: Login & Model Selection

Choose an AI model based on:

Speed
Accuracy
Cost (if applicable)

🖥️ Interface Deep Dive

1. Editor Panel

Where code is written and modified.

2. Agent Panel

Shows active AI agents and their progress.

3. Artifact Viewer

Displays outputs like logs, files, and execution results.

4. Console

Shows runtime execution and errors.

🤖 How AI Agents Work (Real Flow)

When you give a prompt, the system follows this pipeline:

Understand the goal
Create a plan
Generate code
Execute code
Debug errors
Return final output

🛠️ Your First Project: Expense Tracker App

Step 1: Give Prompt

Build a simple expense tracker web app with:
- Add expense
- List expenses
- Total calculation
- Clean UI

Step 2: Agent Planning

The agent will:

Create project structure
Decide frontend + backend
Prepare database logic

Step 3: Code Generation

Files created may include:

index.html
style.css
app.js

Step 4: Execution

The app runs inside the environment or browser.

Step 5: Refinement Prompt

Improve UI with modern design and add category filter

⚡ Advanced Features

1. Multi-Agent Collaboration

Run multiple agents:

Frontend agent
Backend agent
Testing agent

2. Browser Automation

Agents can:

Open websites
Scrape data
Test UI flows

3. Iterative Development

You can continuously improve apps using prompts:

Add authentication system

4. Debug Mode

Agents automatically:

Detect errors
Fix bugs
Re-run code

💡 Best Prompts for Better Results

Bad Prompt ❌

Create app

Good Prompt ✅

Create a responsive expense tracker using HTML, CSS, and JavaScript.
Include add, delete, and total calculation features.

Pro Tip

Always include:

Tech stack
Features
UI expectations

🐞 Debugging & Optimization

Check console logs
Review artifacts
Refine prompts instead of rewriting everything
Break large tasks into smaller steps

🌍 Real-World Use Cases

Startup MVP development
Internal tools
Automation scripts
AI-powered dashboards
Rapid prototyping

⚠️ Limitations

Not always 100% accurate
Complex apps may need manual fixes
Requires prompt clarity

✅ Best Practices

Start small
Use clear prompts
Iterate step-by-step
Review before execution

🏁 Conclusion

Google Antigravity is not just a tool—it’s a new way of building software. By combining AI agents with development workflows, it allows you to build faster, smarter, and more efficiently.

If you master prompt-driven development today, you’ll stay ahead in the future of programming.

📌 SEO Keywords

Google Antigravity tutorial, AI coding platform, agent-based development, AI app builder, build apps with AI, future programming tools, AI development workflow

Lucky Kudam App Review – Your Go-To Kerala Lottery Results Checker

2026-01-08T01:29:00.002+05:30

If you regularly follow Kerala State Lottery results, the Lucky Kudam Android app is a simple and useful solution. It helps you check official lottery results directly on your mobile without visiting multiple websites or checking newspapers.

🔎 What Is Lucky Kudam?

Lucky Kudam is an Android application developed by AJ Softwares that displays Kerala State Lottery results in one place. It is ideal for users who want quick access to winning numbers after the official result announcement.

🚀 Key Features

Daily Kerala Lottery Results – Updated as soon as results are published
Prize-wise Results – Easily check winning numbers by prize category
Notifications – Get alerts when new results are available
Simple & Lightweight UI – Clean design with no unnecessary options
Mobile Optimized – Works smoothly on most Android devices
Official Results Only – Results shown only after confirmation

📊 Supported Lotteries

Karunya
Karunya Plus
Nirmal
Win-Win
Sthree Sakthi
Bhagyalakshmi
Samrudhi
And more

This wide coverage makes the app helpful for users who track multiple Kerala lottery draws.

🧠 User Experience

Easy and clutter-free navigation
Fast loading performance
No login or registration required

The app does not include advanced features like ticket scanning, result history, or prediction tools.

⚠️ Data Privacy & Safety

According to the app listing, no personal data is collected or shared. This makes Lucky Kudam a safe option for privacy-conscious users.

📈 Pros & Cons

👍 Pros

Fast and reliable lottery result updates
Simple and lightweight application
Notification support for new results
No personal information required

👎 Cons

No past result history
Limited only to Kerala lotteries
Ads included (common in free apps)

📌 Final Verdict

Lucky Kudam is a great choice for Kerala lottery players who want a fast, reliable, and easy way to check results. While it keeps things basic, it delivers exactly what it promises—official lottery results without distractions.

If you regularly check Kerala lottery results, this app is definitely worth trying.

Building End-to-End PDF Automation in .NET Using IronPDF: A Complete Practical Guide

2025-12-13T02:00:00.003+05:30

PDF files play a major role in almost every industry. Whether it’s invoices, reports, onboarding forms, medical summaries, account statements, contracts, or audit logs, companies rely heavily on documents that must be accurate, secure, and consistent. As the volume of data grows, so does the need for a dependable way to generate and manage PDFs without manually stitching everything together.

This is where IronPDF steps in and makes a meaningful difference for .NET developers.

Instead of wrestling with low-level PDF internals or outdated libraries, IronPDF lets you work with familiar tools like HTML, CSS, and C#, while still delivering polished, professional PDFs. In this guide, we’ll walk through a full, practical setup that shows how to build a robust automation system using IronPDF —complete with rendering, merging, extracting content, securing documents, converting to PDF/A, and even generating monthly statements automatically.

1. Why IronPDF Makes PDF Work So Much Easier

IronPDF stands out because it uses a Chrome-based rendering engine behind the scenes. That means whatever you can build for a browser—layouts, styles, scripts—you can turn into a PDF with very little effort.

Highlights at a glance:

Convert HTML to PDF with full CSS support
Generate PDFs straight from URLs
Work with PDF merging, splitting, and page-level manipulation
Extract text and images from existing PDFs
Apply passwords and permissions
Convert documents into PDF/A, which is often required for compliance
Works seamlessly across .NET Framework, .NET 6/7/8, Azure, Linux, Docker, and more

Everything demonstrated in this guide mirrors real project requirements found in finance, SaaS, e-commerce, HR, logistics, and enterprise reporting systems.

2. Installing IronPDF

Getting started is as simple as adding the package:

NuGet Package Manager

Install-Package IronPDF

.NET CLI

dotnet add package IronPDF

3. What This Sample Project Demonstrates

Here’s everything covered inside our complete example setup:

Feature	Included
Converting HTML to PDF	✅
Rendering website URLs	✅
Using template-driven PDF generation	✅
Merging and splitting documents	✅
Extracting text and images	✅
Converting PDF pages to images	✅
Adding passwords and permissions	✅
Generating PDF/A compliant files	✅
Automated monthly statement workflow	✅

The goal is for you to have a blueprint that can fit into any production system.

📁 Full Sample Project: IronPdfDemo (.NET 8)

Below is a complete runnable project. Simply place the files in a folder, restore dependencies, and run it.

Project Structure

IronPdfDemo/
│
├── IronPdfDemo.csproj
├── Program.cs
│
├── Templates/
│     └── InvoiceTemplate.html
│
├── Statements/
│
├── Models/
│     └── User.cs
│
└── Services/
      ├── PdfService.cs
      ├── HtmlTemplateService.cs
      ├── StatementService.cs
      └── EmailService.cs

1. IronPdfDemo.csproj

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="IronPDF" Version="2024.9.2" />
  </ItemGroup>
</Project>

2. Templates/InvoiceTemplate.html

<!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: Arial; padding: 20px; }
        h1 { color: #0077cc; }
        .amount { font-size: 22px; margin-top: 20px; }
    </style></head><body>    <h1>Invoice #{{InvoiceNumber}}</h1>    <p>Customer Name: <b>{{CustomerName}}</b></p>    <p>Date: {{Date}}</p>    <p class="amount">Total Amount: <b>${{Amount}}</b></p></body>
</html>

3. Models/User.cs

namespace IronPdfDemo.Models;
public class User{
    public int Id { get; set; }
    public string CustomerName { get; set; } = "";
    public double Amount { get; set; }
    public string Email { get; set; } = "";
    public string InvoiceNumber { get; set; } = "";
}

4. Services/HtmlTemplateService.cs

using System.IO;
namespace IronPdfDemo.Services;
public class HtmlTemplateService{
    public string RenderTemplate(string filePath, Dictionary<string, string> data)
    {        var html = File.ReadAllText(filePath);
        foreach (var kv in data)
            html = html.Replace($"{{{{{kv.Key}}}}}", kv.Value);
        return html;
    }
}

5. Services/PdfService.cs — All Core IronPDF Features

using IronPDF
;
namespace IronPdfDemo.Services;
public class PdfService{
    private readonly ChromePdfRenderer renderer;
    public PdfService()
    {        renderer = new ChromePdfRenderer();
    }
    public PdfDocument RenderHtml(string html) =>
        renderer.RenderHtmlAsPdf(html);
    public PdfDocument RenderUrl(string url) =>
        renderer.RenderUrlAsPdf(url);
    public void Save(PdfDocument pdf, string path) =>
        pdf.SaveAs(path);
    public PdfDocument Merge(params string[] files)
    {        var docs = files.Select(PdfDocument.FromFile).ToList();
        var merged = docs.First();
        foreach (var doc in docs.Skip(1))
            merged.AppendPdf(doc);
        return merged;
    }
    public List<PdfDocument> Split(string path)
    {        var pdf = PdfDocument.FromFile(path);
        return pdf.SplitToIndividualPages().ToList();
    }
    public string ExtractText(string path) =>
        PdfDocument.FromFile(path).ExtractAllText();
    public void ExtractImages(string path)
    {        var pdf = PdfDocument.FromFile(path);
        var images = pdf.ExtractAllImages();
        int i = 1;
        foreach (var img in images)
            img.Save($"image-{i++}.png");
    }
    public void ConvertToImages(string path)
    {        var pdf = PdfDocument.FromFile(path);
        var pages = pdf.ToPngs();
        int i = 1;
        foreach (var img in pages)
            img.Save($"page-{i++}.png");
    }
    public void SecurePdf(string path, string password)
    {        var pdf = PdfDocument.FromFile(path);
        pdf.Password = password;
        pdf.SecuritySettings.AllowUserPrinting = false;
        pdf.SaveAs("secured.pdf");
    }
    public void ConvertToPdfA(string path)
    {        var pdf = PdfDocument.FromFile(path);
        var pdfA = pdf.ConvertToPdfA(PdfAStandard.A2A);
        pdfA.SaveAs("output-pdfa.pdf");
    }
}

6. Services/EmailService.cs (Mock for Demo)

namespace IronPdfDemo.Services;
public class EmailService{
    public Task SendAsync(string to, string subject, string message, string attachmentPath)
    {        Console.WriteLine($"(Mock Email Sent) -> {to} : {attachmentPath}");
        return Task.CompletedTask;
    }
}

7. Services/StatementService.cs — Automated Statement Workflow

using IronPdfDemo.Models;
namespace IronPdfDemo.Services;
public class StatementService{
    private readonly PdfService pdfService;
    private readonly HtmlTemplateService templateService;
    private readonly EmailService emailService;
    public StatementService(PdfService pdf, HtmlTemplateService template, EmailService email)
    {        pdfService = pdf;
        templateService = template;
        emailService = email;
    }
    public async Task GenerateStatementAsync(User user)
    {        var data = new Dictionary<string, string>
        {
            { "CustomerName", user.CustomerName },
            { "Amount", user.Amount.ToString("F2") },
            { "Date", DateTime.Now.ToShortDateString() },
            { "InvoiceNumber", user.InvoiceNumber }
        };
        var html = templateService.RenderTemplate("Templates/InvoiceTemplate.html", data);
        var pdf = pdfService.RenderHtml(html);
        var filePath = $"Statements/Statement-{user.Id}-{DateTime.Now:yyyy-MM}.pdf";
        pdf.SaveAs(filePath);
        pdfService.ConvertToPdfA(filePath);
        await emailService.SendAsync(user.Email, "Your Monthly Statement", "Attached PDF", filePath);
    }
}

8. Program.cs — Running All Features

using IronPdfDemo.Models;
using IronPdfDemo.Services;
var pdfService = new PdfService();var templateService = new HtmlTemplateService();var emailService = new EmailService();var statementService = new StatementService(pdfService, templateService, emailService);
// 1. HTML → PDFvar htmlPdf = pdfService.RenderHtml("<h1>Hello from IronPDF
</h1>");pdfService.Save(htmlPdf, "hello.pdf");
// 2. URL → PDFvar urlPdf = pdfService.RenderUrl("https://example.com");pdfService.Save(urlPdf, "webpage.pdf");
// 3. Mergevar merged = pdfService.Merge("hello.pdf", "webpage.pdf");pdfService.Save(merged, "merged.pdf");
// 4. Splitvar pages = pdfService.Split("merged.pdf");int i = 1;
foreach (var page in pages)
    page.SaveAs($"page-{i++}.pdf");
// 5. Extract TextConsole.WriteLine(pdfService.ExtractText("hello.pdf"));
// 6. Extract ImagespdfService.ExtractImages("merged.pdf");
// 7. Convert Pages to ImagespdfService.ConvertToImages("merged.pdf");
// 8. Secure PDFpdfService.SecurePdf("hello.pdf", "mypassword123");
// 9. Convert to PDF/ApdfService.ConvertToPdfA("hello.pdf");
// 10. Automated Monthly Statementvar user = new User{
    Id = 1,
    CustomerName = "John Doe",
    Amount = 349.99,
    Email = "john@example.com",
    InvoiceNumber = "INV-2025-001"
};
await statementService.GenerateStatementAsync(user);
Console.WriteLine("All IronPDF operations completed successfully!");

Conclusion: A Practical, Production-Ready PDF Automation Workflow

With IronPDF, .NET developers can avoid the tedious parts of PDF manipulation and instead focus on building clean, predictable workflows. The combination of HTML rendering, structured APIs, and compliance features like PDF/A support makes it suitable for everything from financial statements and HR documents to automated reporting systems in SaaS platforms.

This guide gives you:

A refined, publication-ready article
A complete example project you can integrate or expand
Real-world use cases covering extraction, security, automation, and conversions

You now have everything needed for a strong contest submission or for building real enterprise-grade PDF solutions.

.NET 10 Kills MessagingCenter — Here’s the Modern Replacement for Your MAUI App

2025-11-18T01:35:00.000+05:30

With the release of .NET 10 , Microsoft has officially removed MessagingCenter , a long-standing feature that many Xamarin.Forms and early MAUI developers relied on for lightweight communication between components. If your app still uses MessagingCenter, this change may feel disruptive — but the truth is, better, safer, and more maintainable options have already replaced it.

This article explains why MessagingCenter is gone, the recommended modern alternatives, and how you can migrate your MAUI app smoothly without breaking existing functionality.

Why MessagingCenter Was Removed

MessagingCenter was originally introduced for simple publish–subscribe messaging, but over time developers ran into repeated issues:

Hidden communication made debugging difficult
Subscriptions often caused memory leaks
It didn’t align with dependency injection or MVVM best practices
Modern .NET messaging tools are cleaner and more efficient

To encourage better architecture and avoid unpredictable behavior, Microsoft removed MessagingCenter entirely in .NET 10.

Meet the Modern Replacement: WeakReferenceMessenger

The best replacement — and Microsoft’s deliberate direction — is WeakReferenceMessenger , part of the .NET Community Toolkit.

Why it’s better

Strongly typed messages
No memory leaks thanks to weak references
Great for MVVM
Fully supported and actively updated
Faster and more optimized than MessagingCenter

It provides the same pub/sub workflow, but without the pitfalls.

Basic Usage Examples

Send a message

WeakReferenceMessenger.Default.Send(new UserLoggedInMessage(userId));

Receive a message

WeakReferenceMessenger.Default.Register<UserLoggedInMessage>(this, (r, m) =>
{
    // Handle login message
});

Message definition

public class UserLoggedInMessage : ValueChangedMessage<string>
{
    public UserLoggedInMessage(string value) : base(value) { }
}

This pattern is clean, simple, and scales beautifully as your app grows.

Migrating From MessagingCenter to WeakReferenceMessenger

Here’s a common real-world example.

Old (MessagingCenter):

MessagingCenter.Subscribe<HomePage, string>(this, "LoggedIn", (sender, value) =>
{
    // handle login
});

New (WeakReferenceMessenger):

    WeakReferenceMessenger.Default.Register<LoggedInMessage>(this, (r, m) =>
{
    // handle login
});

Send the message

WeakReferenceMessenger.Default.Send(new LoggedInMessage("success"));

Migration Tips for Large Apps

If your MAUI app uses MessagingCenter heavily, follow this structured migration path:

Search for all MessagingCenter usages
Create equivalent message classes
Replace subscriptions with registrations
Replace publish calls with messenger sends
Test navigation scenarios for memory leaks

With WeakReferenceMessenger’s weak references, cleanup becomes much easier.

Why the New Approach Is Better for Your App

Switching to modern messaging patterns gives you:

Cleaner, more predictable architecture
Faster message handling
Zero hidden dependencies
Fewer memory leaks
Easier debugging and testing
Future-proofing for new .NET MAUI updates

MessagingCenter may be gone, but the alternatives are significantly better.

Final Thoughts

The removal of MessagingCenter in .NET 10 marks the end of an old era — and the beginning of a cleaner, more modern approach to app communication. Whether you migrate to WeakReferenceMessenger , traditional events, or a DI-driven pattern, your MAUI app will benefit from improved maintainability and performance.

.NET MAUI is Coming to Linux and the Browser like Flutter

2025-11-15T00:14:00.003+05:30

.NET MAUI is Coming to Linux and the Browser — Powered by Avalonia

The Avalonia UI team has announced a groundbreaking update for .NET developers — .NET MAUI applications are now coming to Linux and the browser, powered by an Avalonia-based backend. This exciting development opens the door for MAUI apps to run seamlessly across desktop Linux, embedded systems, and even WebAssembly.

Expanding MAUI’s Reach

Until now, .NET MAUI primarily supported Windows, macOS, Android, and iOS. With Avalonia’s new rendering backend, developers can extend their MAUI apps to Linux desktops (Ubuntu, Fedora, Debian) and embedded devices like Raspberry Pi. Even more impressively, early builds already demonstrate MAUI applications running inside browsers via WebAssembly — without plugins or external dependencies.

Why Avalonia?

Avalonia’s cross-platform rendering engine provides a consistent UI experience across all systems. It’s known for its performance and lightweight design, which make it ideal for embedded and browser environments. On macOS, early performance tests show more than 2× improvement compared to the native Mac Catalyst backend.

Highlights from the Avalonia Team

MAUI apps now run on Linux and WebAssembly using Avalonia as the rendering layer.
Open-source backend under the MIT license (in development).
Improved consistency and performance across platforms.
Early demo shows MAUI apps running directly in browsers.
Support for desktop, embedded, and browser-based deployments.

What This Means for Developers

This integration means developers can finally target a broader range of platforms without rewriting their apps. Instead of relying on multiple native toolkits, MAUI developers can use Avalonia to deliver a unified experience everywhere.

For teams maintaining large cross-platform applications, this reduces platform-specific bugs, simplifies maintenance, and significantly improves deployment flexibility.

Looking Ahead

The Avalonia backend for .NET MAUI is still in its early stages, but the future looks promising. As the feature matures, MAUI could truly achieve its original goal: “write once, run everywhere.”

The full article and official demo are available on Avalonia’s blog. Read the full announcement here .

General Analysis

This move marks a major step toward unifying the .NET ecosystem. The combination of MAUI’s developer productivity and Avalonia’s rendering flexibility could redefine how cross-platform .NET apps are built and deployed. If successful, it will bring .NET applications to devices and environments that were previously unreachable — from industrial embedded systems to browser-based user interfaces.

Source: Avalonia UI Blog — “.NET MAUI is Coming to Linux and the Browser, Powered by Avalonia” (Published Nov 11 2025)

Getting Your .NET MAUI Applications Ready for Google Play's 16 KB Memory Page Requirement

2025-10-01T10:07:00.002+05:30

A critical deadline is approaching for .NET MAUI developers who distribute applications through Google Play. Beginning November 1, 2025, Google Play will mandate that all new applications and updates designed for Android 15 and higher must be compatible with 16 KB page sizes on 64-bit devices.

Understanding the 16 KB Memory Page Requirement

Android is transitioning from its traditional 4 KB memory page architecture to a larger 16 KB format. This shift is designed to enhance performance on modern devices equipped with substantial RAM. The benefits of this architectural change extend beyond system-level improvements and directly impact individual applications:

Faster Application Launch: Applications experience an average 3.16% reduction in launch time, with some apps seeing improvements up to 30%
Enhanced Energy Efficiency: Power consumption during app launch decreases by an average of 4.56%
Better System Responsiveness: The overall Android operating system becomes more responsive. For example, the native camera app shows 4.48% faster hot starts and 6.60% faster cold starts

Compatibility with .NET MAUI

The positive news for developers is that .NET MAUI 9 includes native support for 16 KB page sizes. To ensure your application meets Google's requirements, simply migrate your .NET MAUI (or .NET for Android) project to .NET 9. Once upgraded, your application will automatically comply with the 16 KB page size standard.

Important Note: Keep in mind that .NET MAUI 8 reached its end-of-support date on May 14, 2025, according to the official .NET MAUI support policy.

Auditing Your Project Dependencies

Compliance isn't just about your main application—every dependency in your .NET MAUI project must also support 16 KB page sizes. During the build process, the system will alert you to any non-compliant dependencies with warnings similar to:

Android 16 will require 16 KB page sizes, shared library '{library_name}' does not have a 16 KB page size. Please inform the authors of the NuGet package '{package_name}' version '{version}' which contains '{file_path}'. See https://developer.android.com/guide/practices/page-sizes for more details.

When encountering these warnings, follow this approach:

Upgrade the problematic dependency to a newer version with 16 KB support
Reach out to package maintainers if no compatible version exists
Consider alternative packages if the original is no longer actively maintained

For developers who want to perform additional verification, Google provides command-line tools in their documentation that can help validate compliance for your application and its dependencies.

Your Preparation Checklist

To meet the November 2025 deadline, follow these steps:

Migrate to .NET 9 if you're currently on an earlier version
Analyze all dependencies for 16 KB page size compatibility
Update or substitute any dependencies that don't meet the requirements
Thoroughly test your application in a 16 KB environment using Android emulators or developer options on physical Android devices

            Critical Reminder: Don't postpone this work until the last moment. Begin your preparation immediately to ensure smooth app submissions that comply with Google Play policies and maintain uninterrupted release schedules.
        

Final Thoughts

While the 16 KB page size requirement introduces a new compliance obligation, it also delivers tangible performance improvements. The .NET MAUI 9 framework is already equipped to handle this requirement—your responsibility is ensuring your dependencies are equally prepared. Upgrade to .NET 9, conduct a thorough dependency audit, and validate your application in 16 KB testing environments to be ready well before the November 2025 cutoff date.

DreamFlow: Revolutionizing Flutter App Development – A No-Code Solution for the Future

2025-06-29T16:20:00.003+05:30

In the fast-paced world of mobile app development, efficiency and speed are paramount. For Flutter developers, a new tool is emerging that promises to significantly accelerate the initial stages of app creation: DreamFlow.

This innovative no-code AI app builder is designed to generate actual cross-platform Flutter applications, offering a unique advantage for those working within the Flutter ecosystem. Facing long development cycles and costly initial prototyping? DreamFlow transforms the game for Flutter developers.

What Makes DreamFlow Stand Out?

Unlike many other no-code platforms, DreamFlow specifically focuses on Flutter, providing a dedicated solution that understands the nuances of this popular framework. This specialization means that developers can expect outputs that are genuinely Flutter-native, rather than generic code that might require extensive modifications.

Key Features:

Flutter-native outputs for seamless integration.
AI-powered app design tailored to developer prompts.
Cross-platform compatibility, reducing development time.

The Simple Workflow

Getting started with DreamFlow is straightforward, simplifying the app development process into a few easy steps:

Create an Account: Begin by setting up your DreamFlow account.
Frame Your Prompt: Describe your desired application using a clear and concise prompt, such as: “Create a weather app with a 5-day forecast, daily temperature graphs, and location-based data.” The more detailed your prompt, the better the generated outcome will be.
Generate the App: With your prompt in place, DreamFlow's AI takes over, quickly generating your Flutter application.
Preview and Refine: Once generated, you can preview your app to ensure it meets your vision.

A Practical Example: Event Management App

Imagine needing a tech event management and booking application. Using a prompt generated by ChatGPT, DreamFlow can conjure a polished app within minutes. This includes:

A clean and modern design.
Intuitive navigation for seamless user experience.
Smooth animations.
Functional data modules for booking and event management.

The beauty of DreamFlow lies in its ability to provide a solid foundation. If further customization is needed, the generated app can even be edited in tools like FlutterFlow.

Current Limitations to Consider

While DreamFlow offers significant advantages, it's important to acknowledge its current limitations. It's not designed to handle:

Deep state management.
Complex custom business logic.
Scalable architectural patterns.
Intricate API integration patterns.

However, many of these limitations can be mitigated by extending the functionality of the generated app using Flutter libraries and manual coding.

The Verdict: A Time-Saving Power Tool

Despite these limitations, DreamFlow proves to be an excellent asset for swiftly building base applications, creating demos, or testing new concepts. It excels at saving substantial UI development time, allowing developers to focus on the more complex, custom aspects of their projects. DreamFlow isn’t just a tool; it’s a time-saving revolution for Flutter developers. Start your journey today!

Demo

Hands-On with Android Studio Cloud: Streamlined Development in Your Browser

2025-04-20T22:39:00.000+05:30

What is Android Studio Cloud?

Android Studio Cloud is Google’s experimental browser-based IDE that streams a full Linux VM running Android Studio to your web browser. Key features:

Caption: The experimental Android Studio Cloud interface accessed via Firebase Studio

🌐 Access Anywhere: Develop Android apps without local installations
🛠️ Pre-Configured Workspaces: Preloaded with Android SDK & IDE
🧪 Experimental Tech: Tests streaming/cloud development workflows
🔄 Git Integration: Import projects directly from GitHub/VCS

Caption: Creating a new cloud workspace

Getting Started

Visit Android Studio Cloud via Firebase Studio
Click "Try Android Studio Cloud"
Name your workspace and click Create
Wait ~2-5 minutes for the Linux VM to initialize

Caption: Web-based Android Studio with Gemini AI integration

Key Workflows to Test

Emulator Deployment:
- Use preconfigured Pixel 8a API 35 (slow first boot – wait 10+ mins)
- Alternative: Stream to physical devices via Firebase Device Streaming
AI Development:
- Leverage Gemini for code completion/suggestions
Version Control:
- Import projects using Get from VCS
Sample Projects:
- Explore via Import Android Code Sample

Caption: Recommended emulator configurations for better performance

Current Limitations (July 2024)

🐢 Slow Emulators: Nested virtualization causes lag
⌨️ Linux Key Mapping Required
🔒 2FA Restrictions: Physical security keys unsupported
🚫 No Local Device Deployment
⚠️ Frequent "Choose password for new keyring" popups – click Cancel

Caption: Common popups to ignore during testing

Why Try It?

Test cutting-edge cloud development infrastructure
Evaluate browser-based IDE performance
Provide feedback to shape future Android tools

Conclusion

While not yet production-ready, Android Studio Cloud offers a fascinating glimpse into browser-first Android development. Developers interested in cloud IDEs or remote workflows should experiment with it – but keep expectations low for now.

Try it here: Android Studio Cloud Preview

Consuming HTTP Calls in .NET MAUI Using HttpClient

2025-03-02T22:14:00.002+05:30

Introduction

.NET MAUI (Multi-platform App UI) is a modern framework that enables developers to create cross-platform applications for Android, iOS, macOS, and Windows using a single codebase. In most applications, consuming data from REST APIs is a fundamental requirement. .NET provides the HttpClient class, a powerful and versatile way to handle HTTP requests and responses.

In this article, we will demonstrate how to use HttpClient in a .NET MAUI application to perform GET, POST, PUT, and DELETE operations. We will also display the results using a simple UI, showing responses in JSON format via alerts.

Prerequisites

Before you start, ensure you have the following:

Development Environment:
- .NET 7.0 SDK installed on your machine.
- Visual Studio 2022 with the .NET MAUI workload installed.
Basic Knowledge:
- Familiarity with C# and .NET programming.
- Basic understanding of REST APIs.
Sample API:
- For this tutorial, we will use the placeholder API available at JSONPlaceholder.

Steps to Implement HTTP Operations in .NET MAUI

1. Create a .NET MAUI Project

Open Visual Studio and create a new .NET MAUI App project. Name it HttpClientSample.

2. Define a Model Class

Create a Post class to represent the data structure returned by the API.

public class Post
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Body { get; set; }
    public int UserId { get; set; }
}

3. Create an API Service Class

Encapsulate the logic for making HTTP requests in a reusable service class.

ApiService.cs

using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;

public class ApiService
{
    private readonly HttpClient _httpClient;
    private readonly JsonSerializerOptions _jsonOptions;

    public ApiService()
    {
        _httpClient = new HttpClient
        {
            BaseAddress = new Uri("https://jsonplaceholder.typicode.com/")
        };
        _jsonOptions = new JsonSerializerOptions
        {
            PropertyNameCaseInsensitive = true,
            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
            WriteIndented = true
        };
    }

    public async Task<List<Post>> GetPostsAsync()
    {
        var response = await _httpClient.GetAsync("posts");
        response.EnsureSuccessStatusCode();
        var json = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize<List<Post>>(json, _jsonOptions);
    }

    public async Task<Post> CreatePostAsync(Post newPost)
    {
        var jsonContent = new StringContent(JsonSerializer.Serialize(newPost, _jsonOptions), Encoding.UTF8, "application/json");
        var response = await _httpClient.PostAsync("posts", jsonContent);
        response.EnsureSuccessStatusCode();
        var json = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize<Post>(json, _jsonOptions);
    }

    public async Task<Post> UpdatePostAsync(int id, Post updatedPost)
    {
        var jsonContent = new StringContent(JsonSerializer.Serialize(updatedPost, _jsonOptions), Encoding.UTF8, "application/json");
        var response = await _httpClient.PutAsync($"posts/{id}", jsonContent);
        response.EnsureSuccessStatusCode();
        var json = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize<Post>(json, _jsonOptions);
    }

    public async Task<bool> DeletePostAsync(int id)
    {
        var response = await _httpClient.DeleteAsync($"posts/{id}");
        return response.IsSuccessStatusCode;
    }
}

4. Build the User Interface

Design the UI in MainPage.xaml with buttons for each HTTP operation.

MainPage.xaml

<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="HttpClientSample.MainPage"
             Title="HTTP Client Demo">

    <StackLayout Padding="20" Spacing="15">
        <Label Text="HTTP Operations"
               FontSize="24"
               HorizontalOptions="Center" />

        <Button Text="GET Data"
                Clicked="OnGetClicked" />

        <Button Text="POST Data"
                Clicked="OnPostClicked" />

        <Button Text="PUT Data"
                Clicked="OnPutClicked" />

        <Button Text="DELETE Data"
                Clicked="OnDeleteClicked" />
    </StackLayout>
</ContentPage>

5. Implement Button Event Handlers

Add event handlers in the MainPage.xaml.cs to invoke the respective methods from the ApiService.

MainPage.xaml.cs

using System.Text.Json;

public partial class MainPage : ContentPage
{
    private readonly ApiService _apiService;

    public MainPage()
    {
        InitializeComponent();
        _apiService = new ApiService();
    }

    private async void OnGetClicked(object sender, EventArgs e)
    {
        try
        {
            var posts = await _apiService.GetPostsAsync();
            string json = JsonSerializer.Serialize(posts, new JsonSerializerOptions { WriteIndented = true });
            await DisplayAlert("GET Response", json, "OK");
        }
        catch (Exception ex)
        {
            await DisplayAlert("Error", ex.Message, "OK");
        }
    }

    private async void OnPostClicked(object sender, EventArgs e)
    {
        try
        {
            var newPost = new Post { Title = "New Post", Body = "This is a new post body", UserId = 1 };
            var createdPost = await _apiService.CreatePostAsync(newPost);
            string json = JsonSerializer.Serialize(createdPost, new JsonSerializerOptions { WriteIndented = true });
            await DisplayAlert("POST Response", json, "OK");
        }
        catch (Exception ex)
        {
            await DisplayAlert("Error", ex.Message, "OK");
        }
    }

    private async void OnPutClicked(object sender, EventArgs e)
    {
        try
        {
            var updatedPost = new Post { Title = "Updated Title", Body = "Updated Body", UserId = 1 };
            var updatedData = await _apiService.UpdatePostAsync(1, updatedPost);
            string json = JsonSerializer.Serialize(updatedData, new JsonSerializerOptions { WriteIndented = true });
            await DisplayAlert("PUT Response", json, "OK");
        }
        catch (Exception ex)
        {
            await DisplayAlert("Error", ex.Message, "OK");
        }
    }

    private async void OnDeleteClicked(object sender, EventArgs e)
    {
        try
        {
            var isDeleted = await _apiService.DeletePostAsync(1);
            string message = isDeleted ? "Post deleted successfully." : "Failed to delete the post.";
            await DisplayAlert("DELETE Response", message, "OK");
        }
        catch (Exception ex)
        {
            await DisplayAlert("Error", ex.Message, "OK");
        }
    }
}

Conclusion

In this article, we explored how to use HttpClient in a .NET MAUI application to perform CRUD operations on a REST API. We created a reusable service class for HTTP requests, designed a simple UI, and displayed results in JSON format using alerts. This implementation is a starting point for integrating REST APIs into your .NET MAUI applications.

Feel free to extend this example by adding features such as error handling, logging, and more advanced UI elements. Happy coding!

Exploring Android 15 and the First Developer Preview of Android 16

2024-11-24T14:09:00.000+05:30

Android 15: Revolutionizing Mobile Experiences

Android 15, codenamed Vanilla Ice Cream, was a significant leap forward in mobile OS innovation. Released earlier this year, it focused on delivering enhanced security, communication, and usability features for both everyday users and enterprise environments.

Key Features in Android 15:

Private Space:
Android 15 introduced Private Space, a virtual sandbox within the OS. This feature allows users to store sensitive files, apps, and data separately from the main environment, ensuring confidentiality. It's especially useful for professionals managing personal and work accounts on the same device.
Enhanced Satellite Messaging:
Taking connectivity to the next level, Android 15 supports satellite communication. While initially limited to premium devices, this feature ensures users remain connected even in remote or offline areas, marking a step forward in global communication capabilities.
Partial Screen Recording:
This innovative tool lets users record specific sections of their screen instead of the entire display. Ideal for sharing specific app workflows or sensitive content without revealing everything on-screen, it became a favorite among tech influencers and educators.
Advanced Security Measures:
Android 15 strengthened device security by including monthly security patches, encrypted backup improvements, and app activity transparency, ensuring user safety against modern digital threats.
Performance Optimizations:
With improved energy efficiency and reduced background process consumption, Android 15 extended battery life and boosted performance, especially on mid-range devices.

Android 16 Developer Preview: A Glimpse into the Future

Android 16 aims to build on Android 15’s solid foundation with groundbreaking improvements and cutting-edge technology. The first developer preview teases several enhancements that cater to developers and end-users alike.

What’s New in Android 16?

AI-Enhanced Personalization:
Android 16 integrates artificial intelligence deeply into the OS to adapt to individual usage patterns. From predictive app suggestions to dynamic interface adjustments, AI creates a more intuitive user experience.
Cross-Device Harmony:
Google is focusing on seamless cross-device operations, making it easier to transition between Android-powered smartphones, tablets, and wearable devices. Developers can leverage new APIs to build apps that offer consistent experiences across device ecosystems.
Sustainability and Efficiency:
The latest version takes sustainability seriously by introducing features that optimize energy consumption. Enhanced battery management tools and smarter resource allocation extend device life and reduce carbon footprints.
Advanced Accessibility Features:
Accessibility tools are getting a major upgrade, ensuring inclusivity for all users. Enhanced voice control, real-time transcription, and assistive gesture navigation are some of the highlights aimed at supporting diverse user needs.
Developer-Centric Updates:
Android 16 offers new tools to developers, including improvements to Jetpack Compose for creating responsive UI designs, updated debugging tools, and extended support for foldable and large-screen devices.

Why Developers Should Explore the Preview:

The first developer preview is a goldmine for app creators, allowing them to adapt their apps early to leverage Android 16's new capabilities. From API testing to performance benchmarking, this is a pivotal moment for the developer community to innovate alongside the OS.

Conclusion

Android 15 and Android 16 demonstrate Google’s unwavering commitment to enhancing the mobile experience. While Android 15 brought essential upgrades in security, connectivity, and usability, Android 16 pushes boundaries with AI-driven innovation and sustainability. Developers and users can look forward to a transformative era in mobile technology as these advancements become mainstream.

For developers, now is the time to dive into the Android 16 Developer Preview and explore its offerings to craft the next generation of apps that define the Android experience.

References

Android 15 Features

Android 16 Features

Image Generated using Chat GPT & DALL-E

.NET MAUI Welcomes Syncfusion Open-source Contributions

2024-11-10T16:56:00.002+05:30

In an exciting development for .NET MAUI, Syncfusion has made significant open-source contributions by releasing 14 essential UI components for free, empowering developers to enhance their applications. These components, found on GitHub and accessible via NuGet, include popular elements like Shimmer and offer capabilities for improved interactivity and visual appeal in .NET MAUI projects. This collaboration underscores Syncfusion’s commitment to the .NET ecosystem and signals a robust future for cross-platform development.

Syncfusion’s contributions align with Microsoft’s broader strategy to expand .NET MAUI’s open-source potential, paving the way for additional community involvement and accelerating the platform’s maturity. A noteworthy part of this collaboration is the ongoing support from Syncfusion for any potential issues and their active involvement in refining the developer experience.

In addition to these components, Microsoft and Syncfusion are working on introducing a new .NET MAUI project template with .NET 9. This template will come preconfigured with Syncfusion’s UI tools, alongside other third-party toolkits, to streamline project setup for developers. This streamlined experience will make it easier for developers to create well-structured, cross-platform applications that perform seamlessly on multiple devices.

Overall, this partnership demonstrates how .NET MAUI is evolving with rich community-driven contributions and shows promising advancements for developers aiming to build sophisticated, cross-platform mobile and desktop applications.

For more details, you can read the original blog post here.

How to Apply Custom Fonts in .NET MAUI

2024-11-06T16:25:00.003+05:30

Adding custom fonts in .NET MAUI (Multi-platform App UI) is a powerful way to improve your app’s design and branding, making it stand out to users across all platforms, including Android, iOS, Windows, and macOS. In this guide, we’ll go through each step required to integrate custom fonts into your .NET MAUI app effectively, helping you achieve a polished, professional look.

Why Use Custom Fonts in .NET MAUI?

Custom fonts provide numerous benefits:

Brand Consistency: Reinforce your brand identity by using fonts that align with your style.
Improved Readability: Choose fonts that enhance the readability and aesthetics of your app, improving the user experience.
Unique Design: Differentiate your app from others by using custom fonts that reflect the purpose and personality of your app.

Adding custom fonts in .NET MAUI is simple and can significantly impact your app's overall design.

Steps to Add Custom Fonts in .NET MAUI

This tutorial breaks down the process into three essential steps:

1. Add the Font File to Your .NET MAUI Project
2. Register the Font in MauiProgram.cs
3. Use the Custom Font in Your XAML or C# Code

Let’s go through each step in detail.

Step 1: Add the Font File to Your .NET MAUI Project

Download the Font: Find a .ttf (TrueType Font) or .otf (OpenType Font) file of your desired font.
Place the Font in the Correct Folder: Drag and drop the font file into the Resources/Fonts folder in your .NET MAUI project. This step is crucial because .NET MAUI loads custom fonts directly from this folder.
Example: If your font file is named MyCustomFont.ttf, place it in Resources/Fonts.

Step 2: Register the Font in `MauiProgram.cs`

After adding the font file to your project, the next step is to register it in MauiProgram.cs to ensure .NET MAUI recognizes it.

Open MauiProgram.cs in your project.
Locate the ConfigureFonts Method: Inside the CreateMauiApp method, find ConfigureFonts and add a new line to register your font file. Here’s how it should look:
```
builder.ConfigureFonts(fonts =>
{
    fonts.AddFont("MyCustomFont.ttf", "MyCustomFontAlias");
});
```
- "MyCustomFont.ttf" is the font file name located in Resources/Fonts.
- "MyCustomFontAlias" is the alias name for the font, which you will use to apply the font in XAML or C#.

Step 3: Use the Custom Font in XAML or C#

With the font registered, it’s now ready to use in your UI.

Using the Font in XAML

To apply the custom font to a control in XAML, use the FontFamily property with the alias you created.

<Label Text="Hello, .NET MAUI!"
       FontFamily="MyCustomFontAlias"
       FontSize="24"
       TextColor="Black"/>

Using the Font in C#

If you prefer to set the font programmatically in C#, you can apply it like this:

Label label = new Label
{
    Text = "Hello, .NET MAUI!",
    FontFamily = "MyCustomFontAlias",
    FontSize = 24,
    TextColor = Colors.Black
};

Tips for Successful Font Integration

Check File Names: Ensure that the font file name in MauiProgram.cs matches the actual file name, including case sensitivity.
Confirm Licensing: Verify the font’s licensing if you’re using it commercially to avoid copyright issues.
Compatibility: Test the font across all supported platforms to make sure it appears correctly on Android, iOS, Windows, and macOS.

Benefits of Using Custom Fonts in .NET MAUI

Custom fonts bring a range of benefits:

Consistent Appearance: Once set up, the font will appear consistently across all platforms.
Enhanced User Experience: A well-chosen font can make your app more user-friendly and visually appealing.
Cross-Platform Design: MAUI makes it easy to use custom fonts without additional platform-specific coding, simplifying cross-platform development.

Wrapping Up

Custom fonts can transform the look and feel of your .NET MAUI app, making it more engaging and unique. By following these steps, you’ll be able to easily add and apply custom fonts across all pages in your app. This customization not only enhances user experience but also boosts your app's professionalism and appeal. With .NET MAUI, you can bring your app's design to life with fonts that make an impression! Start experimenting with different fonts and see how they can elevate your app's style.

🚀 Exciting Update for the QR Generator Plugin! 🚀

2024-09-09T00:44:00.001+05:30

I'm thrilled to announce that a new version of the QRGenerator plugin has just been released! 🎉

This update brings several enhancements and new features to make your QR code generation even more efficient and user-friendly.

Whether you’re developing for Android or looking to integrate QR code functionality into your applications, this update is designed to streamline your workflow and improve performance.

Key Features
🔹 QR code color can be changed dynamically
🔹 Android X support is included
🔹 Minimum support from version 14 is included
🔹 Margin of the QR code can be controlled

You can explore the full release notes and get the updated version at my QRGenerator GitHub Repository.

A big thank you to the community for your ongoing support and feedback. Your contributions and suggestions help make QRGenerator better with each update.

Feel free to try out the new version and let me know your thoughts or any issues you encounter. Happy coding! 💻✨

Detect Long Press in .NET MAUI App using TouchBehavior

2024-06-24T23:25:00.003+05:30

Introduction

In this tutorial, we will show you how to implement a long press gesture in .NET MAUI using TouchBehavior from the MAUI Community Toolkit. Learn how to trigger long press events or commands with parameters and see a live example of updating a button image on a successful long press.

Project Setup:

Launch Visual Studio 2022, and in the start window click Create a new project to create a new project.
In the Create a new project window, select MAUI in the All project types drop-down, select the .NET MAUI App template, and click the Next button:
In the configure your new project window, name your project, choose a suitable location for it, and click the Next button:
In the Additional information window, click the Create button:
Once the project is created, we can able to see the Android, iOS, Windows and other running options in the toolbar. Press the emulator or run button to build and run the app

Install Plugin

We need to install the "CommunityToolkit.MAUI" by searching in nuget manager and click "Install" to install the plugin

Implementation

Here, we will add the long press behaviour to the image control and you can use as per your need:

Add the below code in the xaml file to have wire-up the event or command between the designer and view model. Add Namespace
```
xmlns:toolkit="http://schemas.microsoft.com/dotnet/2022/maui/toolkit"
```

Add the following code in your element. In this example, I used Image control

<Image.Behaviors>
      <toolkit:TouchBehavior LongPressCommand="LongPressCommand" LongPressDuration="2000" />
</Image.Behaviors>

The event code will be look like the below

LongPressCommand = new Command(() =>
{
	count++;

	if (count == 1)
		CounterBtn.Text = $"Long pressed {count} time";
	else
		CounterBtn.Text = $"Long pressed {count} times";

	SemanticScreenReader.Announce(CounterBtn.Text);
});

Download Code:

You can download the code from GitHub. If you have any doubts, feel free to post a comment. If you liked this article, and it is useful to you, do like, share the article & star the repository on GitHub.

Video Tutorial and Demo:

.NET MAUI - Handlers

2024-04-29T01:09:00.002+05:30

Introduction

This article explores the concept of .NET MAUI handlers and how they are used in development. Handlers act as a bridge between virtual views and native views on each platform. In simpler terms, they are responsible for instantiating the underlying native view and mapping the cross-platform control API to the native view API. This essentially allows developers to use the same code across different platforms without worrying about the underlying implementation details.

Key concepts of handlers include property mappers and command mappers. These mappers define what actions are taken when a property or command changes. Handlers also support lifecycle events that allow developers to perform actions when a handler is created or changed.

Quick Links:

Project Setup
Implementation
Download Code

Project Setup:

Launch Visual Studio 2022, and in the start window click Create a new project to create a new project.
In the Create a new project window, select MAUI in the All project types drop-down, select the .NET MAUI App template, and click the Next button:
In the configure your new project window, name your project, choose a suitable location for it, and click the Next button:
In the Additional information window, click the Create button:
Once the project is created, we can able to see the Android, iOS, Windows and other running options in the toolbar. Press the emulator or run button to build and run the app

Implementation

Here's a simple example for a .NET MAUI Entry handler:

Conditional Compilation: #if ANDROID and #endif are conditional compilation directives. They ensure the code within them is only compiled for the Android platform and similar to other platforms as well.

Entry Handler Customization: This code customizes the appearance of Entry controls with the name "BorderlessEntry".

Microsoft.Maui.Handlers.EntryHandler.Mapper.AppendToMapping("BorderlessEntry", (handler, view) =>
{
    if (view is Entry)
    {
        #if ANDROID
        handler.PlatformView.SetBackgroundColor(Microsoft.Maui.Graphics.Colors.Beige.ToAndroid());
        #elif IOS
        handler.PlatformView.BorderStyle = UIKit.UITextBorderStyle.None;
        #elif WINDOWS
        handler.PlatformView.BorderThickness = new Microsoft.UI.Xaml.Thickness(10);
        #endif
    }
});

It uses the EntryHandler.Mapper.AppendToMapping method to register a custom mapping for this specific named control.
The lambda expression defines what happens when an Entry with the name "BorderlessEntry" is encountered.
Inside the lambda, it checks if the view is indeed an Entry control.
Then, depending on the platform (Android, iOS, or Windows), it applies platform-specific styling:
- On Android, the background color is set to beige.
- On iOS, the border style is removed to create a borderless look.
- On Windows, a border thickness of 10 is applied.

This code demonstrates how to customize the appearance of an Entry control in .NET MAUI using handlers. By registering a custom mapping for "BorderlessEntry", you can achieve a platform-specific, borderless look for entries with that specific name. This allows for targeted styling without affecting all Entry controls in your app.

Download Code:

Conclusion:

You can customize various other aspects of the Entry control using platform-specific properties and methods within the handler. This approach allows for a more granular control over the appearance of your UI elements on different platforms while maintaining cross-platform compatibility.

.NET MAUI - Root/Jail Broken Detection

2024-03-24T21:27:00.001+05:30

Introduction

Building a secure .NET MAUI app is essential. Rooted/jailbroken devices bypass security measures, leaving them vulnerable. This can impact your app's data and functionality. Let's explore the risks and how to implement root/jailbreak detection in your .NET MAUI app.

Quick Links:

Project Setup
Install Plugin
Implementation
Download Code

Project Setup:

Launch Visual Studio 2022, and in the start window click Create a new project to create a new project.
In the Create a new project window, select MAUI in the All project types drop-down, select the .NET MAUI App template, and click the Next button:
In the configure your new project window, name your project, choose a suitable location for it, and click the Next button:
In the Additional information window, click the Create button:
Once the project is created, we can able to see the Android, iOS, Windows and other running options in the toolbar. Press the emulator or run button to build and run the app

Install Plugin:

Open your Nuget Package Manager and search "banditoth.MAUI.JailbreakDetector" and install the latest version in your project.

Implementation

Open MainPage.xaml file and update the UI as per your requirement. In this sample, I have added a button to check whether the device is rooted or not.

You can dependency inject the jailbreak detector instance, by resolving an instance of IJailbreakDetector. Store the instance in a private readonly field in your class, or use it directly.

IJailbreakDetectorConfiguration jailbreakDetectorConfiguration = new JailbreakSettings();
jailbreakDetectorConfiguration.MaximumPossibilityPercentage = 20;
jailbreakDetectorConfiguration.MaximumWarningCount = 1;
jailbreakDetectorConfiguration.CanThrowException = true;

IJailbreakDetector jailbreakDetector = new JailberakDetectorService(jailbreakDetectorConfiguration);

Use the following code to check the device is rooted or not.

if (jailbreakDetector.IsSupported())
{
	var isRooted = await jailbreakDetector.IsRootedOrJailbrokenAsync();
	if (isRooted)
	{
		await DisplayAlert("ANDROIDMADS - .NET MAUI", "DEVICE IS ROOTED", "OK");
	}
	else
	{
		await DisplayAlert("ANDROIDMADS - .NET MAUI", "DEVICE IS NOT ROOTED", "OK");
	}
}

Download Code:

Effortlessly Build a PHP API with PHP API Builder - CLI: Step-by-Step Guide

2024-03-13T05:28:00.002+05:30

Introduction:

Building an API in PHP is a fundamental aspect of web development, enabling seamless communication between different software applications. With the PHP API Builder - CLI tool, creating robust APIs becomes a breeze. This command-line interface simplifies the process by generating PHP files tailored for handling Create, Read, Update, and Delete operations (CRUD) on your specified database tables.

PHP API Builder - CLI streamlines API development by automating repetitive tasks, allowing developers to focus on crafting efficient solutions. Whether you're a seasoned developer or just starting with PHP, this tool offers a user-friendly approach to quickly generate API files with minimal effort.

Now, let's dive into the details of using PHP API Builder - CLI to harness the power of PHP for building APIs.

Requirements:

PHP installed on your system.
Access to the database you want to generate API files for.

Usage:

Run the CLI Tool: Open PhpApiBuilder.exe CLI tool where it is located.
Input Hostname: When prompted, enter the hostname of your database server. If it's 'localhost', you can press Enter to proceed with the default value.
Input Database Name: Enter the name of the database you want to generate API files for.
Input Username: Provide the username to access the specified database.
Input Password: If your database requires a password, enter it when prompted. If there's no password, you can press Enter to proceed with an empty password.
Enter PHP File Name: Specify the desired name for the PHP file that will be generated. Do not include the ".php" extension.
Enter Table Name: Input the name of the table for which you want to generate CRUD operations API.
Review Output: Once all the necessary information is provided, the CLI tool will generate the PHP file containing CRUD operations for the specified table. If any errors occur during the process (e.g., invalid credentials, table not found), the CLI will display an error message and prompt you to restart the process from the beginning.
Accessing Generated Files: The generated PHP file will be available in the same directory where the CLI tool is located.

Example:

Suppose you want to generate API files for a database named "my_database" with the table "users". Here's how you would use the PHP API Builder - CLI tool:

Enter hostname (default: localhost): localhost
Enter database name: my_database
Enter username: my_username
Enter password (default: empty):
Enter PHP file name (without .php extension): users_api
Enter table name: users

After providing the necessary information, the tool will generate the "users_api.php" file in the tool's directory.

Note:

Make sure to review the generated PHP file to ensure it meets your requirements and security standards before using it in your project.
It's recommended to back up your database before performing any CRUD operations using the generated API files.
For any assistance or issues with the PHP API Builder - CLI tool, refer to the documentation or contact support.

Conclusion:

This manual provides a comprehensive guide for using the PHP API Builder - CLI tool to efficiently generate API files for CRUD operations on your database tables.

Download:

You can download this tool from GitHub. If you have any doubts, feel free to post a comment. If you liked this article, and it is useful to you, do like, share the article & star the repository on GitHub.

Good Bye Xamarin

2024-02-14T17:38:00.001+05:30

In the ever-evolving landscape of technology, tools and frameworks continuously evolve, and developers must stay ahead of the curve. One significant evolution in recent times is the transition from Xamarin.Forms to .NET MAUI (Multi-platform App UI). This shift brings about a series of changes and deadlines that developers must navigate skillfully. In this article, we'll simplify and explore the essential milestones and recommendations to smoothly transition from Xamarin to .NET MAUI.

Saying Farewell to Xamarin

Xamarin.Forms, the precursor to .NET MAUI, is reaching its twilight phase. Existing Xamarin.Forms projects now have the imperative of migrating to .NET MAUI, with Xamarin itself approaching its expiration date. It's vital to note that support for all Xamarin SDKs, including Xamarin.Forms, will come to an end after May 1, 2024.

For those seeking comprehensive insights into this transition, detailed information and guidelines are available in the official documentation.

Navigating the Transition to .NET 7

Complicating matters further is the impending end of support for .NET 7, scheduled for May 14, 2023. To mitigate potential challenges, it's wise to initiate migrations well in advance, allowing ample time to address any arising issues during the process. For detailed information, delve into the resources provided.

Embracing Visual Studio Code

As Visual Studio for Mac faces retirement by August 31, 2024, developers may find themselves at a crossroads. However, there's no cause for concern as the transition to .NET MAUI can seamlessly continue using Visual Studio Code. Learn how to implement the MAUI Extension for Visual Studio Code and access additional resources in the official documentation.

Understanding App Store Transition Deadlines

The transition timeline extends beyond development environments to app distribution platforms. It's anticipated that by April 2025, the Apple App Store will likely stop accepting submissions of Xamarin applications built with Xcode 15. Similarly, the Google Play Store is expected to cease supporting Xamarin apps targeting API 34 by August 2025.

For more information on these transitions, refer to the provided links.

Fostering Community Engagement

In the spirit of community collaboration, developers are encouraged to share their feedback with the Microsoft team through David Ortinau's facilitated platform. Your experiences are invaluable in enriching the community and streamlining the migration process from Xamarin to .NET MAUI. Participate in the feedback survey to contribute to this collective effort.

Showcasing Your .NET MAUI Creations

As .NET MAUI gains momentum, Microsoft eagerly seeks to showcase applications developed using this framework. Your contributions and feedback play a pivotal role in shaping the future of .NET MAUI. Keep an eye out for Microsoft events where .NET MAUI applications are celebrated and showcased.

In conclusion, transitioning from Xamarin to .NET MAUI signifies a significant milestone in the realm of cross-platform app development. By staying informed, proactive, and leveraging available resources, developers can navigate this transition with confidence and agility, propelling their projects into the future.

Certainly! Here's a tabulated overview of the key dates and their details:

Date	Event	Details
May 1, 2024	End of Xamarin Official Support	Support for all Xamarin SDKs, including Xamarin.Forms, will cease after this date.
May 14, 2023	End of .NET 7 Official Support	Support for .NET 7 will be terminated, urging developers to plan migration strategies well in advance.
August 31, 2024	Retirement of Visual Studio for Mac	Visual Studio for Mac will be retired, prompting developers to transition to alternative environments such as Visual Studio Code.
April 2025	Apple App Store Transition Deadline	The anticipated final deadline for the Apple App Store to accept submissions of Xamarin applications built with Xcode 15.
August 2025	Google Play Store Transition Deadline	The expected final deadline for the Google Play Store to accept Xamarin apps targeting API 34.

These dates serve as crucial milestones for developers navigating the transition from Xamarin to .NET MAUI. It's essential to stay informed and plan accordingly to ensure a smooth and seamless transition process.

.NET MAUI - Base64 Image Encode/Decode

2024-02-04T17:00:00.001+05:30

Introduction

Imagine building an app that works on different devices like phones and computers using .NET MAUI. Sometimes, it's tricky to show images in your app, especially when they're encoded in Base64. This blog helps you figure out how to do that easily. We'll break down the steps, making it simple for 10th-grade students to follow along. By the end, you'll know how to make your app look cool with Base64 images in .NET MAUI!

Quick Links:

Project Setup
Implementation
Demo
Download Code

Project Setup:

Launch Visual Studio 2022, and in the start window click Create a new project to create a new project.
In the Create a new project window, select MAUI in the All project types drop-down, select the .NET MAUI App template, and click the Next button:
In the configure your new project window, name your project, choose a suitable location for it, and click the Next button:
In the Additional information window, click the Create button:
Once the project is created, we can able to see the Android, iOS, Windows and other running options in the toolbar. Press the emulator or run button to build and run the app

Implementation

Open MainPage.xaml file and update the UI as per requirement. And below my screen design.

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MauiBase64Image.MainPage">

    <ScrollView>
        <VerticalStackLayout
            Spacing="25"
            Padding="30,0"
            VerticalOptions="Center">

            <Label
                x:Name="base64Result"
                Text=""
                MaxLines="5"
                SemanticProperties.HeadingLevel="Level1"
                FontSize="12"
                HorizontalOptions="Center" />

            <Button
                x:Name="EncodeBtn"
                Text="Base64 Encode"
                Clicked="OnEncodeClicked"
                HorizontalOptions="Center" />

            <Image
                x:Name="imagePreview"
                HeightRequest="200"
                HorizontalOptions="Center" />

            <Button
                x:Name="DecodeBtn"
                Text="Base64 Decode"
                Clicked="OnDecodeClicked"
                HorizontalOptions="Center" />

        </VerticalStackLayout>
    </ScrollView>

</ContentPage>

Base64 String to Image:

If you're into turning one thing into another, the Convert class in .NET is like a superhero! It helps change stuff, even binary files, into this special code called Base64.

Here's a little example code that shows how to use this superhero class to make a special picture show up in a .NET MAUI app. But here's the trick: don't use the word 'using' like we usually do when talking to the computer. If we do that, it might close the door too early before the picture is ready to show.

var imageBytes = Convert.FromBase64String(base64Result.Text);
MemoryStream imageDecodeStream = new(imageBytes);
imagePreview.Source = ImageSource.FromStream(() => imageDecodeStream);

Image to Base64 String:

Now, let's learn how to do the opposite – turning a picture into a base64 string! We use something called Convert.ToBase64String() in .NET MAUI, which is like a tool for this job.

As you might have guessed, the first step is changing our picture into something called a byte array, which is like breaking it into small pieces. In .NET MAUI, you can grab a file from your app (maybe in the Resources\Raw folder) using the FileSystem tools.

using var imageEncodeStream = await FileSystem.OpenAppPackageFileAsync("icon.png");
using var memoryStream = new MemoryStream();

imageEncodeStream.CopyTo(memoryStream);
base64Result.Text = Convert.ToBase64String(memoryStream.ToArray());

Here's how it works: we turn the picture into a Stream, put it in a special memory place called MemoryStream, and then change it into those small pieces, the byte array. Take a look at this code example to see how it's done.

See those 'using' words? They make sure everything is cleaned up nicely when we finish. Remember, there could be different ways to get files, but as long as you can turn your picture into a byte array, you're good to go in your .NET MAUI journey!

Download Code:

.NET MAUI - Video Player using Community Toolkit

2024-01-08T00:00:00.001+05:30

Introduction

Hey! Ever wanted to create cool apps for different devices like phones and computers? Well, .NET MAUI makes it super easy. It's like a superhero for app creators! Now, imagine adding fun things like videos to your apps. That's where the Community Toolkit comes in – a toolbox that lots of developers work on together. Today, we're exploring the Video Player control, a cool feature powered by .NET MAUI and its friendly Community Toolkit. Get ready for an adventure in making your apps more exciting with videos!

Quick Links:

Project Setup
Install Plugin
Implementation
Demo
Download Code

Project Setup:

Launch Visual Studio 2022, and in the start window click Create a new project to create a new project.
In the Create a new project window, select MAUI in the All project types drop-down, select the .NET MAUI App template, and click the Next button:
In the configure your new project window, name your project, choose a suitable location for it, and click the Next button:
In the Additional information window, click the Create button:
Once the project is created, we can able to see the Android, iOS, Windows and other running options in the toolbar. Press the emulator or run button to build and run the app

Install Plugin:

Open Terminal or Command Prompt: Open a terminal or command prompt window. You can usually find this on your computer by searching for "Command Prompt" (Windows) or "Terminal" (macOS/Linux).
Navigate to Your Project Folder: Use the cd command to navigate to your .NET MAUI project folder. For example:
Install Community Toolkit: Run the following command to install the CommunityToolkit.Maui package:
```
dotnet add package Microsoft.Maui.CommunityToolkit
```
Restore Packages: After the installation, run the following command to restore the packages:
```
dotnet restore
```

Implementation

First, we need to open "MauiProgram.cs" and include the following namespace and line to allow the app to use the Chart Library.
```
using CommunityToolkit.Maui;
```
```
.UseMauiCommunityToolkit()
.UseMauiCommunityToolkitMediaElement()
```
Open MainPage.xaml file and add the following namespace. (the page will be replaced according to you).
```
xmlns:toolkit="http://schemas.microsoft.com/dotnet/2022/maui/toolkit"
```

Then, remove the default content and add an instance of the Media Element class to the page.

<toolkit:MediaElement Source="https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4"
ShouldShowPlaybackControls="True"
BackgroundColor="AliceBlue"
x:Name="mediaElement"/>

We can add other controls for custom video controls like play/pause and volume controls like below.

<HorizontalStackLayout BindingContext="{x:Reference mediaElement}"
					      HorizontalOptions="Center"
					      Spacing="10">
	
	<Button Text="Play"
		HorizontalOptions="CenterAndExpand"
		Clicked="OnPlayPauseButtonClicked">
	</Button>
	<Button Text="Stop"
		HorizontalOptions="CenterAndExpand"
		Clicked="OnStopButtonClicked">
	</Button>
</HorizontalStackLayout>
<Slider Maximum="1.0"
		   Minimum="0.0"
		   Value="{Binding Volume}"
		   ValueChanged="Slider_ValueChanged"  
		   Rotation="270"
		   WidthRequest="100" />

Open Code behind and add the following which will be useful to controls media elements using custom controls.

void OnPlayPauseButtonClicked(object sender, EventArgs args)
{
	if (mediaElement.CurrentState == MediaElementState.Stopped ||
		mediaElement.CurrentState == MediaElementState.Paused)
	{
		mediaElement.Play();
	}
	else if (mediaElement.CurrentState == MediaElementState.Playing)
	{
		mediaElement.Pause();
	}
}

void OnStopButtonClicked(object sender, EventArgs args)
{
	mediaElement.Stop();
}

private void Slider_ValueChanged(object sender, ValueChangedEventArgs e)
{
	mediaElement.Volume = e.NewValue;
}

Download Code:

.NET MAUI - 2023 Recap

2024-01-04T18:23:00.006+05:30

In this video, we will see the recap of .NET MAUI articles post on 2023. Supercharge your .NET MAUI projects by referring this articles.

DEV EXPRESS CHARTS IN .NET MAUI

December 04, 2023

Lottie animations in .NET MAUI

November 19, 2023

Transforming Labels into Hyperlinks with .NET MAUI

November 12, 2023

Mastering MVVM: A Deep Dive into .NET MAUI with MVVM Toolkit

October 28, 2023

Dev Express - Data Grid Control for .NET MAUI (Lifetime - Free plugin)

October 15, 2023

Data Grid Control for .NET MAUI (Free plugin to Sort, Filter & Show Data)

October 04, 2023

.NET MAUI - Swipe View

September 17, 2023

Flyout Page in .NET MAUI

July 21, 2023

.NET MAUI Barcode Scanner using IRONBARCODE

July 02, 2023

Dynamic Status Bar in .NET MAUI

June 18, 2023

Localisation in .NET MAUI

June 12, 2023

File Picker in .NET MAUI

May 29, 2023

Toast in .NET MAUI

May 21, 2023

Avatar View in .NET MAUI Community Toolkit

May 07, 2023

Signature Pad using .NET MAUI Community Toolkit

April 16, 2023

.Net MAUI - QR Code Generator

January 05, 2023

.Net MAUI - Zxing Barcode Scanner

January 10, 2023

DEV EXPRESS CHARTS IN .NET MAUI

2023-12-04T14:00:00.001+05:30

Introduction

Supercharge your .NET MAUI projects with Devexpress Charts! This blog will explain you how to implement the chart in .NET MAUI projects using Dev express, a life time free plugin. This plugin has many customisations and will directly skip into the implementation part.

Quick Links:

Project Setup
Install Plugin
Implementation
Demo
Download Code

Project Setup:

Launch Visual Studio 2022, and in the start window click Create a new project to create a new project.
In the Create a new project window, select MAUI in the All project types drop-down, select the .NET MAUI App template, and click the Next button:
In the configure your new project window, name your project, choose a suitable location for it, and click the Next button:
In the Additional information window, click the Create button:
Once the project is created, we can able to see the Android, iOS, Windows and other running options in the toolbar. Press the emulator or run button to build and run the app

Install Plugin:

Library Requirement: The Dev express's nuget link should be mapped as a package source and we need to install "DevExpress.Maui.Charts" into our project.
Installation via NuGet: Obtain the Charts library by searching for "DevExpress.Maui.Charts" in the NuGet Package Manager.
User Interface Guidance: Open the NuGet Package Manager interface to facilitate the installation process.
Visual Confirmation: The library, once searched, should appear as "DevExpress.Maui.Charts" in the NuGet interface.

Implementation

First, we need to open "MauiProgram.cs" and include the following namespace and line to allow the app to use the Chart Library.
```
using DevExpress.Maui;
```
```
.UseDevExpress()
```
Open MainPage.xaml file and add the following namespace. (the page will be replaced according to you).
```
xmlns:dxc="clr-namespace:DevExpress.Maui.Charts;assembly=DevExpress.Maui.Charts"
```

Then, remove the default content and add an instance of the ChartView class to the page.

<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:dxc="clr-namespace:DevExpress.Maui.Charts;assembly=DevExpress.Maui.Charts"
             x:Class="ScatterChartGetStarted.MainPage">
    <dxc:ChartView/>
</ContentPage>

Consider removing the event handlers from the code-behind for the default content. It is advisable to eliminate default styles (such as fonts, colors, and other settings) in the App.xaml file as well.

In this instance, the chart features line series displaying the annual GDP for three countries. Generate a ViewModel.cs file that includes the following classes:

public class ViewModel {
    public CountryGdp GdpValueForUSA { get; }
    public CountryGdp GdpValueForChina { get; }
    public CountryGdp GdpValueForJapan { get; }

    public ViewModel() {
        GdpValueForUSA = new CountryGdp(
            "USA",
            new GdpValue(new DateTime(2020, 1, 1), 20.93),
            new GdpValue(new DateTime(2019, 1, 1), 21.43),
            new GdpValue(new DateTime(2018, 1, 1), 20.58),
            new GdpValue(new DateTime(2017, 1, 1), 19.391),
            new GdpValue(new DateTime(2016, 1, 1), 18.624),
            new GdpValue(new DateTime(2015, 1, 1), 18.121),
            new GdpValue(new DateTime(2014, 1, 1), 17.428),
            new GdpValue(new DateTime(2013, 1, 1), 16.692),
            new GdpValue(new DateTime(2012, 1, 1), 16.155),
            new GdpValue(new DateTime(2011, 1, 1), 15.518),
            new GdpValue(new DateTime(2010, 1, 1), 14.964)
        );
        GdpValueForChina = new CountryGdp(
            "China",
            new GdpValue(new DateTime(2020, 1, 1), 14.72),
            new GdpValue(new DateTime(2019, 1, 1), 14.34),
            new GdpValue(new DateTime(2018, 1, 1), 13.89),
            new GdpValue(new DateTime(2017, 1, 1), 12.238),
            new GdpValue(new DateTime(2016, 1, 1), 11.191),
            new GdpValue(new DateTime(2015, 1, 1), 11.065),
            new GdpValue(new DateTime(2014, 1, 1), 10.482),
            new GdpValue(new DateTime(2013, 1, 1), 9.607),
            new GdpValue(new DateTime(2012, 1, 1), 8.561),
            new GdpValue(new DateTime(2011, 1, 1), 7.573),
            new GdpValue(new DateTime(2010, 1, 1), 6.101)
        );
        GdpValueForJapan = new CountryGdp(
            "Japan",
            new GdpValue(new DateTime(2020, 1, 1), 4.888),
            new GdpValue(new DateTime(2019, 1, 1), 5.082),
            new GdpValue(new DateTime(2018, 1, 1), 4.955),
            new GdpValue(new DateTime(2017, 1, 1), 4.872),
            new GdpValue(new DateTime(2016, 1, 1), 4.949),
            new GdpValue(new DateTime(2015, 1, 1), 4.395),
            new GdpValue(new DateTime(2014, 1, 1), 4.850),
            new GdpValue(new DateTime(2013, 1, 1), 5.156),
            new GdpValue(new DateTime(2012, 1, 1), 6.203),
            new GdpValue(new DateTime(2011, 1, 1), 6.156),
            new GdpValue(new DateTime(2010, 1, 1), 5.700)
        );
    }
}

public class CountryGdp {
    public string CountryName { get; }
    public IList<GdpValue> Values { get; }

    public CountryGdp(string country, params GdpValue[] values) {
        this.CountryName = country;
        this.Values = new List<GdpValue>(values);
    }
}

public class GdpValue {
    public DateTime Year { get; }
    public double Value { get; }

    public GdpValue(DateTime year, double value) {
        this.Year = year;
        this.Value = value;
    }
}

In the MainPage.xaml file, incorporate three LineSeries objects into the ChartView.Series collection. To establish a connection between the series and data, assign each LineSeries object's Data property to a SeriesDataAdapter object. Utilize the adapter's properties to indicate the data source and fields containing arguments and values for each series.

Additionally, define a local XAML namespace referring to a CLR namespace encompassing the view model. Subsequently, employ the page's BindingContext property to link the view model with the view.

<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"  
             xmlns:dxc="clr-namespace:DevExpress.Maui.Charts;assembly=DevExpress.Maui.Charts"
             xmlns:ios="clr-namespace:Microsoft.Maui.Controls.PlatformConfiguration.iOSSpecific;assembly=Microsoft.Maui.Controls"
             ios:Page.UseSafeArea="True"
             xmlns:local="clr-namespace:MauiDevExpress"
             x:Class="MauiDevExpress.MainPage">
    <ContentPage.BindingContext>
        <local:ViewModel/>
    </ContentPage.BindingContext>
    <dxc:ChartView>
        <dxc:ChartView.Series>
            <dxc:LineSeries DisplayName="{Binding GdpValueForUSA.CountryName}">
                <dxc:LineSeries.Data>
                    <dxc:SeriesDataAdapter DataSource="{Binding GdpValueForUSA.Values}"
                                           ArgumentDataMember="Year">
                        <dxc:ValueDataMember Type="Value" Member="Value"/>
                    </dxc:SeriesDataAdapter>
                </dxc:LineSeries.Data>
            </dxc:LineSeries>

            <dxc:LineSeries DisplayName="{Binding GdpValueForChina.CountryName}">
                <dxc:LineSeries.Data>
                    <dxc:SeriesDataAdapter DataSource="{Binding GdpValueForChina.Values}"
                                           ArgumentDataMember="Year">
                        <dxc:ValueDataMember Type="Value" Member="Value"/>
                    </dxc:SeriesDataAdapter>
                </dxc:LineSeries.Data>
            </dxc:LineSeries>

            <dxc:LineSeries DisplayName="{Binding GdpValueForJapan.CountryName}">
                <dxc:LineSeries.Data>
                    <dxc:SeriesDataAdapter DataSource="{Binding GdpValueForJapan.Values}"
                                           ArgumentDataMember="Year">
                        <dxc:ValueDataMember Type="Value" Member="Value"/>
                    </dxc:SeriesDataAdapter>
                </dxc:LineSeries.Data>
            </dxc:LineSeries>
        </dxc:ChartView.Series>
    </dxc:ChartView>
</ContentPage>

Configure the X-axis to display labels for years by assigning a DateTimeAxisX object with the specified settings to the ChartView.AxisX property.

<dxc:ChartView> <dxc:ChartView.AxisX>
    <dxc:DateTimeAxisX MeasureUnit="Year" GridAlignment="Year"
    GridSpacing="2"/> </dxc:ChartView.AxisX> </dxc:ChartView>

Configure the title and labels on the Y-axis. Set the ChartView.AxisY property to a NumericAxisY object and specify this object’s Title and Label properties.

<dxc:ChartView> 
<!-- The X-axis config is here. -->
    <dxc:ChartView.AxisY>
        <dxc:NumericAxisY>
            <dxc:NumericAxisY.Title>
                <dxc:AxisTitle Text="Trillions of US$">
                    <dxc:AxisTitle.Style>
                        <dxc:TitleStyle>
                            <dxc:TitleStyle.TextStyle>
                                <dxc:TextStyle Size="16"/>
                            </dxc:TitleStyle.TextStyle>
                        </dxc:TitleStyle>
                    </dxc:AxisTitle.Style>
                </dxc:AxisTitle>
            </dxc:NumericAxisY.Title>
            <dxc:NumericAxisY.Label>
                <dxc:AxisLabel TextFormat="#.#" Position="Inside"/>
            </dxc:NumericAxisY.Label>
        </dxc:NumericAxisY>
    </dxc:ChartView.AxisY>
</dxc:ChartView>

Configure the legend position and orientation. Set the ChartView.Legend property to a Legend object, and specify this object’s properties as follows:

<dxc:ChartView>
    <dxc:ChartView.Legend>
        <dxc:Legend VerticalPosition="TopOutside" 
                    HorizontalPosition="Center" 
                    Orientation="LeftToRight"/>
    </dxc:ChartView.Legend>
</dxc:ChartView>

Establish the chart to showcase a series point hint as a crosshair cursor by setting the ChartView.Hint property to a Hint object and assigning a CrosshairHintBehavior object to Hint.Behavior. Subsequently, define the hint's content, data format, and visibility options. Set the LineSeries.HintOptions property to a SeriesCrosshairOptions object with the specified settings.

<ContentPage.Resources>
    <dxc:SeriesCrosshairOptions x:Key="lineSeriesHintOptions"
                                PointTextPattern="{}{S}: {V}M"
                                ShowInLabel="True"
                                AxisLabelVisible="True"
                                AxisLineVisible="True"/>
</ContentPage.Resources>
<dxc:ChartView>
    <dxc:ChartView.Hint>
        <dxc:Hint>
            <dxc:Hint.Behavior>
                <dxc:CrosshairHintBehavior GroupHeaderTextPattern="{}{A$YYYY}" 
                                           MaxSeriesCount="3"/>
            </dxc:Hint.Behavior>
        </dxc:Hint>
    </dxc:ChartView.Hint>

    <dxc:ChartView.Series>
        <dxc:LineSeries HintOptions="{StaticResource lineSeriesHintOptions}">
            <!--Series Data-->
        </dxc:LineSeries>
        <dxc:LineSeries HintOptions="{StaticResource lineSeriesHintOptions}">
            <!--Series Data-->
        </dxc:LineSeries>
        <dxc:LineSeries HintOptions="{StaticResource lineSeriesHintOptions}">
            <!--Series Data-->
        </dxc:LineSeries>
    </dxc:ChartView.Series>    
</dxc:ChartView>

Set the LineSeries.MarkersVisible property to True to display point markers. To change the line series appearance, set the LineSeries.Style property to a LineSeriesStyle object. This object’s Stroke, StrokeThickness, MarkerSize, and MarkerStyle properties allow you to configure the appearance of the series line and point markers.

<dxc:LineSeries MarkersVisible="True">
    <!--Series Data-->
    <dxc:LineSeries.Style>
        <dxc:LineSeriesStyle Stroke="#7145a7" StrokeThickness="2" MarkerSize="8">
            <dxc:LineSeriesStyle.MarkerStyle>
                <dxc:MarkerStyle Fill="#7145a7"/>
            </dxc:LineSeriesStyle.MarkerStyle>
        </dxc:LineSeriesStyle>
    </dxc:LineSeries.Style>
</dxc:LineSeries>

Demo

Download Code:

Lottie animations in .NET MAUI

2023-11-19T20:14:00.002+05:30

Introduction

Supercharge your .NET MAUI projects with Lottie animations! Imagine it as the magic wand for your app's visuals. Thanks to Adobe After Effects, Lottie speaks a special language called JSON, making animations a breeze. Meet SkiaSharp, a Microsoft buddy that helps Lottie shine in .NET MAUI, making your app look cool without the complexity. Learn the ropes in our beginner-friendly guide! Add a dash of Lottie, sprinkle in some JSON magic, and watch your app come to life!

Top advantages of Lottie Animations:

Vector-based Adaptability: Lottie animations, being vector-based, ensure seamless scalability without compromising resolution.
Reduced File Size: Compared to formats like GIF or MP4, Lottie files boast significantly smaller sizes while maintaining top-notch quality.

Quick Links:

Project Setup
Install Plugin
Implementation
Demo
Download Code

Project Setup:

Launch Visual Studio 2022, and in the start window click Create a new project to create a new project.
In the Create a new project window, select MAUI in the All project types drop-down, select the .NET MAUI App template, and click the Next button:
In the configure your new project window, name your project, choose a suitable location for it, and click the Next button:
In the Additional information window, click the Create button:
Once the project is created, we can able to see the Android, iOS, Windows and other running options in the toolbar. Press the emulator or run button to build and run the app

Install Plugin:

Library Requirement: SkiaSharp library is essential for displaying Lottie animations.
Installation via NuGet: Obtain the SkiaSharp library by searching for "SkiaSharp.Extended.UI.Maui" in the NuGet Package Manager.
Enable Prerelease: Ensure the "Include prerelease" flag is enabled during installation, as MAUI support is currently in prerelease.
User Interface Guidance: Open the NuGet Package Manager interface to facilitate the installation process.
Visual Confirmation: The library, once searched, should appear as "SkiaSharp.Extended.UI.Maui" in the NuGet interface.

Implementation

First, we need to open "MauiProgram.cs" and include the following namespace and line to allow the app to use the Lottie Animations.
```
using SkiaSharp.Views.Maui.Controls.Hosting;
```
```
.UseSkiaSharp()
```
Open MainPage.xaml file and add the following namespace. (the page will be replaced according to you)
```
xmlns:skia="clr-namespace:SkiaSharp.Extended.UI.Controls;assembly=SkiaSharp.Extended.UI"
```
Unlocking the magic of Lottie animations in your .NET MAUI app is a breeze! If you have JSON files, just add them to the Resources\Raw subfolder. For web-hosted animations, effortlessly consume them by passing the URI to the Lottie view. Explore the treasure trove of free and paid animations on Lottiefiles.com, a popular source for dynamic visuals. In our example, we'll use a JSON animation from the Lottie library repository, already included in the code for your convenience. Feel free to switch it up with your preferred animation!
We need to add the animation to the Raw folder: Go to Resources ➡ Raw ➡ Right click add ➡ Existing files ➡ animation.json (walking_batman.json in my sample).

<skia:SKLottieView RepeatCount="-1"
                           RepeatMode="Reverse"
                           Source="walking_batman.json" 
                           HeightRequest="400"
                           WidthRequest="400" />

<skia:SKLottieView>: This is the declaration of the SKLottieView, a specialized view for rendering Lottie animations using the SkiaSharp library.
RepeatCount="-1": The RepeatCount attribute determines how many times the animation should repeat. A value of -1 means it will repeat indefinitely.
RepeatMode="Reverse": The RepeatMode attribute sets the behavior of the animation when it repeats. In this case, "Reverse" means the animation will play in reverse each time it repeats.
Source="walking_batman.json": Specifies the source of the Lottie animation. In this example, the animation is loaded from a file named "Girl.json" located in the project.
HeightRequest="400" and WidthRequest="400": These attributes set the desired height and width of the SKLottieView, in this case, both set to 400. This property is very important to visualize Lottie animation.

This code essentially integrates a Lottie animation (from the "walking_batman.json" file) into your Xamarin.Forms application, configuring its repeat behavior and dimensions. Adjust these attributes based on your specific animation and layout requirements.

Demo

Download Code:

Transforming Labels into Hyperlinks with .NET MAUI

2023-11-12T22:07:00.000+05:30

Introduction

Our phones and computers are like magic doors to the world, thanks to the apps we use every day. These apps show us stuff using a mix of words, pictures, and special links that let us explore more. 🌐 Links, especially, make it easy for us to dive deep into things. In this guide, we'll learn how to add these special links to your .NET MAUI apps, making it more fun for people to check out what you have to share. Join us on this enlightening journey as we unravel the secrets of Transforming Labels into Hyperlinks with .NET MAUI.

Quick Links:

Project Setup
Implementation
Demo
Full Code
Download Code

Project Setup:

Launch Visual Studio 2022, and in the start window click Create a new project to create a new project.
In the Create a new project window, select MAUI in the All project types drop-down, select the .NET MAUI App template, and click the Next button:
In the configure your new project window, name your project, choose a suitable location for it, and click the Next button:
In the Additional information window, click the Create button:
Once the project is created, we can able to see the Android, iOS, Windows and other running options in the toolbar. Press the emulator or run button to build and run the app

Implementation

In this step, we'll include two labels within the horizontal layout to position them closely to each other.
The first text will serve as regular text, representing the standard label.
The second text will function as a hyperlink, characterized by blue text color and underlined as text decoration.
The following code snippet will help in grasping the concept more clearly.

<HorizontalStackLayout>
	<Label
		Text="To know more about .NET MAUI "
		SemanticProperties.HeadingLevel="Level1"
		FontSize="Default"
		HorizontalOptions="Center" />

	<Label
		Text="Visit Here"
		TextDecorations="Underline"
		TextColor="Blue"
		SemanticProperties.HeadingLevel="Level1"
		FontSize="Default"
		HorizontalOptions="Center" >
		<Label.GestureRecognizers>
			<TapGestureRecognizer Tapped="OnUrlClicked"/>
		</Label.GestureRecognizers>
	</Label>
</HorizontalStackLayout>

Incorporate the tap gesture event "OnUrlClicked" to open the specified URL link, as demonstrated below.

private async void OnUrlClicked(object sender, TappedEventArgs e)
{
	await Launcher.OpenAsync("https://www.androidmads.info/search/label/.net%20maui");
}