This handbook provides a practical, step-by-step guide to mastering Multi-Site Manager (MSM) in Adobe Experience Manager (AEM), covering both AEM 6.X and AEM as a Cloud Service (AEMaaCS).

1. Core Concept Overview

MSM allows you to reuse content from a “Source” to multiple “Targets” while maintaining a live connection for updates.

• Blueprint: A source configuration that defines pages to be reused.
• Live Copy: A target site or page that inherits content from a blueprint/source.
• Rollout Configuration: Rules defining when and how content is synchronized (e.g., “On Update”, “On Activation”).

2. Practical Step-by-Step Implementation

Step 1: Establishing the Master Structure

Before using MSM, organize your content hierarchy. Best practice follows a “Language Master” approach.

1. Navigate to Sites console.
2. Create a root folder (e.g., /content/my-brand).
3. Create a Language Master folder (e.g., /content/my-brand/language-masters).
4. Author your primary content in a base language, such as English (/content/my-brand/language-masters/en).

Step 2: Creating a Blueprint Configuration

This step makes your “Language Master” available for live copies.

1. Go to Tools > Sites > Blueprints.
2. Select Create and choose the Blueprint Template.
3. Select your Source Path (e.g., /content/my-brand/language-masters/en).
4. Provide a Title and Name, then click Create.

Step 3: Creating a Live Copy

You can create a Live Copy via the “Create Site” wizard or manually.

1. Via Create Site:

• Select Create > Site.
• Choose your Blueprint (created in Step 2).
• Specify the destination path (e.g., /content/my-brand/us/en).
• Select the Standard Rollout Configuration.

2. Manually (Individual Pages):

• Select the source page in the Sites console.
• Select Create > Live Copy.
• Pick the target destination and required rollout configs.

3. Managing Inheritance & Synchronization

A. Rolling Out Changes (Source to Target)

• Manual Rollout: Select a page in the Language Master, click Properties > Blueprint > Rollout. This pushes changes to all associated Live Copies.
• Automatic Rollout: Configured via “On Modification” or “On Activation” rollout triggers.

B. Breaking Inheritance (Target Localization)

If a local country site needs unique content, you must break inheritance.

1. Open the Live Copy page in Editor.
2. Select a component and click the “Cancel Inheritance” (lock icon).
3. The component can now be edited locally without being overridden by the next rollout.

4. Key Differences: AEM 6.X vs. AEMaaCS

FeatureAEM 6.X (On-Prem/AMS)AEM as a Cloud Service (AEMaaCS)Blueprint UIClassic/Touch UI tools available.Touch UI only; enhanced “Quick Site Creation” tools.Asset MSMManaged via traditional replication.Uses Asset Microservices for cloud-native asset reuse.Rollout SpeedLimited by local server resources.Inherently scalable; optimized for high-volume content distribution.DeploymentMutable content packages via Package Manager.Strict separation of immutable code and mutable content.

5. Troubleshooting & Best Practices

• Avoid Over-Customization: Minimize custom rollout configurations to ensure better system performance and easier upgrades.
• Governance: Establish clear ownership between “Global Authors” (masters) and “Local Authors” (live copies) to prevent accidental overwrites.
• Audit Regularly: Use the Live Copy Overview console to monitor the status of inheritance and synchronization across complex site structures.

Feedback and Discussion

1. What are your biggest challenges with MSM rollouts in AEMaaCS? Share your thoughts in the comments below!
2. Did this guide help clarify the Master/Live Copy relationship? Let me know your key takeaways or any advanced tips you use!

In this blog, we’ll dive deep into the AEM Multifield component, explaining its properties, implementation, and usage with relevant code snippets to help you master its potential.

What is the Multifield Component in AEM?

The Multifield component is a Granite UI widget in AEM that allows authors to add, remove, and reorder multiple entries of similar data. It is commonly used in scenarios where users need to manage lists of content, such as images, links, or other repeated sets of fields.

For example:

• A carousel component might allow authors to add multiple slides, each with an image, title, and description.
• A navigation component might allow authors to define multiple menu items.

Key Features of the Multifield Component

1. Dynamic Input: Authors can add an unlimited number of entries.
2. Complex Structures: Supports nested fields for complex content models.
3. Flexibility: Works with various field types, including text, rich text, dropdowns, and more.

Core Properties of the Multifield Component

Here’s a breakdown of the properties used to configure the Multifield component:

sling:resourceType Defines the type of component (e.g., cq/gui/components/authoring/dialog/multifield).

name The name of the property where data is stored in the repository.

field The child node that defines the structure of individual fields in the multifield.

allowReorder Determines whether authors can reorder items in the Multifield. Defaults to true.

minItems Specifies the minimum number of items required.

maxItems Specifies the maximum number of items allowed.

deleteHint Ensures proper deletion of child nodes when removing items from the Multifield. Defaults to true.

Basic Implementation of the Multifield Component

Let’s look at a simple example where we configure a Multifield component to allow authors to input a list of links with their titles.

Dialog Configuration

Below is the XML code for the Multifield dialog:

<?xml version="1.0" encoding="UTF-8"?>
<jcr:root xmlns:sling="http://sling.apache.org/jcr/sling/1.0"
          xmlns:cq="http://www.day.com/jcr/cq/1.0"
          xmlns:jcr="http://www.jcp.org/jcr/1.0"
          jcr:primaryType="cq:Dialog"
          xmlns:granite="http://www.adobe.com/jcr/granite/1.0">
    <content jcr:primaryType="nt:unstructured"
             sling:resourceType="cq/gui/components/authoring/dialog">
        <items jcr:primaryType="nt:unstructured">
            <content jcr:primaryType="nt:unstructured"
                     sling:resourceType="granite/ui/components/coral/foundation/container">
                <items jcr:primaryType="nt:unstructured">
                    <multifield jcr:primaryType="nt:unstructured"
                                sling:resourceType="cq/gui/components/authoring/dialog/multifield"
                                name="./links"
                                allowReorder="{Boolean}true">
                        <field jcr:primaryType="nt:unstructured"
                               sling:resourceType="granite/ui/components/coral/foundation/container">
                            <items jcr:primaryType="nt:unstructured">
                                <title jcr:primaryType="nt:unstructured"
                                       sling:resourceType="granite/ui/components/coral/foundation/form/textfield"
                                       fieldLabel="Title"
                                       name="./title" />
                                <link jcr:primaryType="nt:unstructured"
                                      sling:resourceType="granite/ui/components/coral/foundation/form/pathfield"
                                      fieldLabel="Link"
                                      name="./link" />
                            </items>
                        </field>
                    </multifield>
                </items>
            </content>
        </items>
    </content>
</jcr:root>

Explanation of the Code

1. Multifield Configuration

• The sling:resourceType is set to cq/gui/components/authoring/dialog/multifield, indicating that this is a Multifield component.
• The name property (./links) specifies the path in the content repository where the data will be stored.
• The allowReorder property is enabled, allowing authors to reorder the links.

2. Field Definition

• The field node defines the structure of each item in the Multifield. In this case, each item consists of two fields:
• A textfield for the title.
• A pathfield for the link.

3. Nested Items

• Each field (title and link) is defined as a child node under the field node with its respective sling:resourceType.

Storing and Retrieving Multifield Data

When authors populate the Multifield and save the dialog, the data is stored in the content repository in a JSON-like structure. For example:

"links": [
  {
    "title": "Adobe",
    "link": "/content/we-retail/home"
  },
  {
    "title": "Google",
    "link": "https://www.google.com"
  }
]

Accessing Multifield Data in HTL (HTML Template Language)

You can retrieve and iterate over the Multifield data in your component’s HTL file as follows:

<div>
  <ul>
    <sly data-sly-list="${model.links}">
      <li>
        <a href="${item.link}" target="_blank">${item.title}</a>
      </li>
    </sly>
  </ul>
</div>

Advanced Usage: Nested Multifield

AEM Multifield supports nested configurations for more complex use cases. For example, a Multifield can contain another Multifield to manage hierarchical data.

Example of Nested Multifield

Here’s an example XML configuration for a nested Multifield:

<multifield jcr:primaryType="nt:unstructured"
            sling:resourceType="cq/gui/components/authoring/dialog/multifield"
            name="./nestedLinks">
    <field jcr:primaryType="nt:unstructured"
           sling:resourceType="cq/gui/components/authoring/dialog/multifield">
        <field jcr:primaryType="nt:unstructured"
               sling:resourceType="granite/ui/components/coral/foundation/container">
            <items jcr:primaryType="nt:unstructured">
                <label jcr:primaryType="nt:unstructured"
                       sling:resourceType="granite/ui/components/coral/foundation/form/textfield"
                       fieldLabel="Label"
                       name="./label" />
                <url jcr:primaryType="nt:unstructured"
                     sling:resourceType="granite/ui/components/coral/foundation/form/pathfield"
                     fieldLabel="URL"
                     name="./url" />
            </items>
        </field>
    </field>
</multifield>

Best Practices for Using Multifield

1. Minimize Nested Multifields: While nested Multifields are powerful, they can complicate the content structure and make debugging more challenging.
2. Use Validation: Leverage AEM’s validation mechanisms to ensure data integrity.
3. Set Boundaries: Use minItems and maxItems to control the number of items authors can add.

Conclusion

The AEM Multifield component is a robust tool that simplifies the management of dynamic and repeated data structures. By understanding its properties, configurations, and best practices, you can create flexible and user-friendly authoring experiences for your AEM projects. Whether you’re building simple lists or complex hierarchical data models, the Multifield component is an essential part of your toolkit.

Let us know how you use Multifield in your AEM projects or if you have any questions in the comments below!

1. Architectural Difference:

2. Deployment Models

AEM 6.5 Deployment

Options:

• On-premise: Hosted on company-owned servers.
• Cloud-hosted: Deployed on third-party cloud providers like AWS, Azure, or GCP.

Deployment Process:

• Involves manual setup of Author and Publish instances, dispatcher configuration, and custom CI/CD pipelines.

Example Use Case:

• A government agency managing sensitive data prefers AEM 6.5 deployed on-premise for complete control over data security.

AEMaaCS Deployment

Options:

• Fully managed by Adobe with no control over the underlying infrastructure.

Deployment Process:

• Cloud Manager provides CI/CD pipelines for automating code and content deployments.
• Configuration involves deploying to predefined cloud environments (Development, Staging, Production).

Example Use Case:

• An e-commerce giant needing quick scalability for seasonal traffic peaks chooses AEMaaCS for its auto-scaling capabilities.

3. Key features comparison

4. Real-world Use Cases

AEM 6.5 Use Cases

Financial Institutions:

• Require on-premise deployment for strict regulatory compliance and control over data.
• Example: A bank uses AEM 6.5 for its public website and secure internal portals.

High Customization Needs:

• Organizations with complex workflows or extensive backend integrations prefer AEM 6.5.
• Example: A global media company develops a highly customized content workflow.

AEMaaCS Use Cases

Scalability and Rapid Deployment:

• Ideal for organizations needing quick scaling for global campaigns.
• Example: An e-commerce platform launches promotional microsites that can handle high traffic during sales events.

Frequent Updates:

• Businesses prioritizing agility and continuous feature updates.
• Example: A fashion brand uses AEMaaCS for a content-rich website with seasonal updates.

5. Integration and API Capabilities

AEM 6.5:

• Allows extensive backend integration with custom APIs.
• Example: Integrating with legacy systems for complex data workflows.

AEMaaCS:

• Focuses on extensibility through Adobe I/O Runtime and cloud-based APIs.
• Example: Using GraphQL APIs to serve content to a Single Page Application (SPA).

Conclusion

Choose AEM 6.5 if:

• You need complete control over the environment.
• Data security and compliance are paramount.
• Extensive customizations are a priority.

Choose AEMaaCS if:

• Scalability and agility are critical.
• You prefer a SaaS model with minimal operational overhead.
• You require frequent updates without maintenance effort.

Both versions are powerful, but the choice depends on the organization’s priorities and technical requirements.

Purpose of AEM

1. Centralized Content Management:

• AEM provides a unified platform for managing digital content, ensuring consistency across various channels and campaigns.

2. Personalization:

• It allows businesses to deliver tailored experiences to specific audiences using real-time insights and data integration.

3. Efficiency in Content Delivery:

• AEM enables rapid content updates and deployment, reducing time-to-market for new campaigns and initiatives.

Key Features of AEM

1. Content Management:

• Easy-to-use interface for creating, editing, and managing content using drag-and-drop functionality.
• Support for reusable components and templates to maintain brand consistency.

2. Digital Asset Management (DAM):

• Robust asset library to store, organize, and retrieve digital assets like images, videos, and documents.

3. Multichannel Delivery:

• Content delivery optimized for web, mobile, IoT devices, and more.

4. Headless CMS Capabilities:

• Support for Content Fragments and GraphQL APIs for delivering structured content to any frontend application.

5. Integration with Adobe Experience Cloud:

• Seamless integration with Adobe Analytics, Target, and Campaign for insights, personalization, and marketing automation.

6. Workflows and Collaboration:

• Built-in workflows for content approvals and publishing.

7. Scalability and Performance:

• Cloud-native architecture in AEM as a Cloud Service for auto-scaling and high availability.

8. Translation and Localization:

• Simplified management of multilingual content using translation tools and language copies.

Use Cases in Digital Experience Management

1. Web Content Management:

• Managing websites for global brands with consistent design and localized content.

2. E-commerce:

• Integration with commerce platforms for product content and personalized shopping experiences.

3. Marketing Campaigns:

• Creating landing pages, promotional content, and microsites to support campaigns.

4. Headless CMS for Mobile Apps:

• Delivering content to native apps or Single Page Applications (SPAs) using APIs.

5. Digital Asset Management:

• Organizing and sharing assets for use across marketing channels and teams.

6. Multilingual Content Delivery:

• Efficiently managing and delivering localized content to global audiences.

7. Customer Personalization:

• Enhancing user experiences using data-driven insights and dynamic content targeting.

Example Workflow

• Content Creation: A content author creates a page using AEM’s intuitive Touch UI, selecting components like text, images, and forms.
• Review and Approval: A built-in workflow routes the page for review and approval.
• Publishing: Upon approval, the page is published to the publish environment, making it live for end-users.
• Analytics Integration: Adobe Analytics tracks user interactions, providing insights to optimize content performance.

AEM’s powerful features and seamless integrations make it an indispensable tool for enterprises aiming to deliver impactful digital experiences efficiently.

• Brief Overview: Explain what Git and GitHub are, their importance in modern software development, and how they work together to manage version control.
• Who This Guide Is For: Mention that this guide is for anyone new to version control, Git, and GitHub, and that it will walk through the basics in a step-by-step manner.

1. Creating Your GitHub Account

Account Creation:

• Describe how to sign up on GitHub.
• Briefly explain the difference between free and paid plans, if relevant.

Setting Up Your Profile:

• Add a profile picture, bio, and relevant information.
• Mention the importance of keeping your GitHub profile active as it acts like a portfolio for developers.

2. Setting Up Git Locally

Installing Git:

• Guide the reader to download Git from the official site and install it on different operating systems (Windows, macOS, Linux).

Initial Setup:

• Run essential setup commands:

bash

git config --global user.name "Your Name"
git config --global user.email "you@example.com"

• Explain that these commands link their commits to their GitHub profile.

Checking Git Version:

• Verify the installation:

bash

git --version

3. Creating and Initializing a Local Repository

Folder Setup:

• Guide them to create a new project folder on their machine.

Initializing the Repository:

• Explain the git init command:

bash

git init

Basic Workflow:

• Mention the workflow: edit → add → commit.
• git add: Stage changes.
• git commit -m "commit message": Commit changes.

Example of basic commands:

bash

echo "# MyProject" >> README.md
git add README.md
git commit -m "Initial commit"

4. Connecting to GitHub and Pushing Your First Code

Creating a GitHub Repository:

• Guide readers through creating a new repository on GitHub and explain public vs. private repos.

Linking Local to Remote:

• Show how to add a GitHub remote:

bash

git remote add origin https://github.com/username/repository.git

Pushing Code to GitHub:

• Explain the git push command:

bash

git push -u origin main

• Discuss branches briefly (e.g., using main or master branch).

5. Essential Git Commands and Tools to Remember

Basic Commands:

• git status: Check the status of your repository.
• git log: View commit history.
• git pull: Sync local repository with remote.
• git clone: Clone a repository.
• git branch: Work with branches.
• git merge: Merge branches.

Advanced Commands (optional):

• Briefly mention git rebase, git stash, git cherry-pick for more advanced readers.

Useful Tools:

• Git GUIs: GitHub Desktop, Sourcetree, and GitKraken for those who prefer graphical interfaces.
• VS Code Integration: Explain how to use Git directly within VS Code.

6. Git and GitHub Best Practices

• Commit Often: Make small, frequent commits.
• Use Descriptive Commit Messages: Explain what each change does for future reference.
• Branching Strategy: Use branches to organize features, bug fixes, and experiments.
• Review and Document: Always review code before merging and document any important changes in the README or comments.

7. Common Mistakes to Avoid

• Not Committing Frequently: Avoid large, infrequent commits.
• Ignoring .gitignore: Always use a .gitignore file to exclude unnecessary files.
• Not Pulling Before Pushing: Remember to sync with the remote repository before pushing changes.

Documentation and Resources

Git Basics:

• Official Git Documentation: https://git-scm.com/doc
• Git Book (an open-source, detailed book on Git): https://git-scm.com/book/en/v2

GitHub:

• GitHub Docs: https://docs.github.com/
• GitHub Learning Lab (guided courses and tutorials): https://lab.github.com/
• GitHub CLI (for managing GitHub from your terminal): https://cli.github.com/manual/

Installing Git:

• Download Git: https://git-scm.com/downloads

Git Workflow and Commands:

• Git Cheat Sheet (official quick reference guide): https://education.github.com/git-cheat-sheet-education.pdf
• Atlassian Git Tutorials: https://www.atlassian.com/git/tutorials

Branching and Merging:

• Git Branching Basics: https://git-scm.com/book/en/v2/Git-Branching-Basic-Branching-and-Merging
• Understanding Git Merge and Rebase: https://www.atlassian.com/git/tutorials/merging-vs-rebasing

Git GUI Tools:

• GitHub Desktop: https://desktop.github.com/
• Sourcetree: https://www.sourcetreeapp.com/
• GitKraken: https://www.gitkraken.com/

.gitignore and Ignoring Files:

• Creating .gitignore Files: https://git-scm.com/docs/gitignore
• GitHub’s Recommended .gitignore Templates: https://github.com/github/gitignore

VS Code and Git:

• VS Code Git Integration: https://code.visualstudio.com/docs/editor/versioncontrol

General Resources:

• Pro Git eBook (available free online, great for advanced topics): https://git-scm.com/book/en/v2
• GitHub Glossary (terms and definitions): https://docs.github.com/en/get-started/quickstart/github-glossary

Conclusion

• Encourage Practice: Reinforce the importance of hands-on practice with Git and GitHub.
• Additional Resources: Suggest further reading or resources like Git documentation, GitHub Learning Lab, and YouTube tutorials for deepening their knowledge.

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

Best Practices for AEM Sling Servlets

1. Component-Based OSGi (Declarative Services) Registration (Recommended)

This is the modern and most preferred way of registering servlets, following OSGi R7 standards. It involves using OSGi Declarative Services (DS) and annotations to register servlets.

Example Code:

import org.apache.sling.api.servlets.SlingAllMethodsServlet;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.osgi.service.component.annotations.Component;
import javax.servlet.Servlet;
import java.io.IOException;

@Component(
    service = Servlet.class,
    property = {
        "sling.servlet.paths=/bin/myservlet",
        "sling.servlet.methods=GET",
        "sling.servlet.extensions=json"
    }
)
public class MySlingServlet extends SlingAllMethodsServlet {
    @Override
    protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response) throws IOException {
        response.setContentType("application/json");
        response.getWriter().write("{\"message\": \"Hello AEM\"}");
    }
}

Key Features of OSGi Component-Based Registration:

• Annotations: Leverages the @Component annotation to define metadata such as the servlet path (sling.servlet.paths), supported HTTP methods (sling.servlet.methods), and file extensions (sling.servlet.extensions).
• Lifecycle Management: OSGi framework manages the servlet lifecycle, including activation and deactivation.
• SlingAllMethodsServlet: Supports multiple HTTP methods (GET, POST, etc.), allowing flexibility.

Pros:

• Modularity: Managed by OSGi Declarative Services, offering modularity and loose coupling.
• Dynamic Service Management: OSGi can dynamically start, stop, and update servlets without restarting the application.
• OSGi Configurations: Can be configured and deployed as an OSGi component, ensuring clarity and separation of concerns.
• Reduced Boilerplate: Use of annotations leads to cleaner and more maintainable code.

Cons:

• Initial Complexity: Slightly more setup involved due to OSGi annotations.
• Learning Curve: Developers need to understand OSGi Declarative Services, which might be complex for newcomers.

2. Traditional Registration via Sling Resource Types (JCR-based)

This method registers servlets using resource type bindings via JCR node configurations or Sling Mapping. It was a more commonly used method before Declarative Services became the norm.

Example Configuration:

In this approach, you define a servlet in JCR by adding a cq:Servlet node under a specific path and assigning it a resource type.

Example Code:

import org.apache.sling.api.servlets.SlingSafeMethodsServlet;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.osgi.service.component.annotations.Component;

@Component(service = Servlet.class, property = {
    "sling.servlet.resourceTypes=myproject/components/structure/page",
    "sling.servlet.methods=GET"
})
public class MyResourceTypeServlet extends SlingSafeMethodsServlet {
    @Override
    protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response) throws IOException {
        response.getWriter().write("This servlet is bound to a resource type.");
    }
}

Pros:

• JCR Binding: Can bind servlets to specific resource types, allowing requests to be processed based on page/component structures.
• Component-Oriented: Ideal for servlets tied to specific content resources or page types.

Cons:

• JCR Overhead: Involves additional configuration in JCR (e.g., defining servlet nodes), making it less flexible for servlet deployment.
• Harder to Test: This approach requires more setup in content repositories, making unit testing more complicated.
• JCR Dependency: Strong dependency on JCR structures, which makes the approach less flexible compared to OSGi.

Choosing the Right Approach

• OSGi Declarative Services (DS) is preferred in most scenarios, especially in AEM as a Cloud Service (AEMaaCS), where modularity and service dynamism are essential. This method offers more flexibility, cleaner configurations, and less dependency on JCR content.
• Resource Type Registration can still be useful if your servlet is closely tied to a specific component-based or resource-based use case, but it’s often more cumbersome and difficult to maintain.

Conclusion

For modern AEM implementations, especially AEM as a Cloud Service, OSGi Declarative Services with annotations is the best practice for registering Sling Servlets. It ensures a cleaner, modular, and more flexible setup with easier management of servlet lifecycle and configurations.

Are you facing trouble with your Intel Dual Band AC 3160 not detecting Jio AirFiber 2.4GHz or 5GHz bands? This issue can be frustrating, but several users have successfully fixed it by following specific troubleshooting steps.

Common Causes
1. Driver Compatibility: If you’re running Windows 10 and using WiFi 6-capable routers, outdated or incorrect drivers for the AC 3160 adapter might be causing the issue.
2. Driver Version: The correct driver version (18.33.17.1) for Windows 10 is key. Many users found that after upgrading to this driver, their Intel Dual Band AC 3160 was able to detect Jio AirFiber networks properly.

Solutions to Try
1. Upgrade the Driver:
 — Update to the driver version 18.33.17.1, which is available in the 21.10.1 package. This driver ensures compatibility with newer WiFi standards and fixes detection issues.
 — You can find archived versions of discontinued drivers online (some community members have shared reliable sources). Intel has stopped hosting these drivers on their official site.

2. Rollback to an Older Driver:
In some cases, users reported success by rolling back to an even older driver version like 17.15.0.5 (dated 2015). This can be a solution if you face compatibility problems with more recent driver versions.

3. Advanced Settings Adjustment:
 — Navigate to the Device Manager and modify the Preferred Band setting under the adapter’s properties in the Advanced tab. This could help force your device to connect to a specific frequency range, either 2.4GHz or 5GHz.

Things to Keep in Mind
- Discontinued Adapter: Intel has stopped supporting the AC 3160 adapter, which makes obtaining official driver updates challenging. However, community-shared resources and forums may help you access the necessary drivers.

- Compatibility with Windows 11: If you plan on upgrading to Windows 11, be cautious. The Intel Dual Band AC 3160 may not be fully supported, and no guarantee exists for a smooth transition. However, some users still find workarounds.

By following these steps, you should be able to get your Intel AC 3160 adapter to detect Jio AirFiber networks.

Further Reading & References:
- [Intel Community Forum on Wireless Adapters](https://community.intel.com/t5/Wireless/Intel-Dual-Band-AC-3160-selectively-not-detecting-Jio-Airfiber-2/m-p/1565651)

Do you need help with specific steps in the process? Let me know!

1. Install AEM 6.5

Download AEM 6.5:

1. Go to the [Adobe Experience Manager downloads page](https://experienceleague.adobe.com/docs/experience-manager-65/release-notes/service-pack/sp-release-notes.html).
2. Download the AEM 6.5 Quickstart jar file.

Start AEM 6.5:

1. Place the Quickstart jar file in a directory (e.g., `C:\AEM\`).
2. Open the command prompt and navigate to the directory containing the jar file.
3. Run the following command to start AEM:
   java -jar aem-quickstart-6.5.jar -nofork
4. Wait for AEM to start. It will be accessible at `http://localhost:4502`.

2. Install Service Packs and Feature Packs

1. Download Service Packs:
   - Visit the [Service Pack download page](https://experienceleague.adobe.com/docs/experience-manager-65/release-notes/service-pack/sp-release-notes.html) and download the latest service pack.
2. Install Service Packs:
   - Log in to AEM at `http://localhost:4502` using the default credentials (`admin` / `admin`).
   - Navigate to `http://localhost:4502/crx/packmgr`.
    — Upload and install the service pack.

3. Configure AEM for Headless

Install Core Components:

1. Download the Core Components package from [Adobe GitHub repository](https://github.com/adobe/aem-core-wcm-components/releases).
2. Install the package via the CRX Package Manager (`http://localhost:4502/crx/packmgr`).

Configure Content Services:

1. Navigate to the AEM Web Console at `http://localhost:4502/system/console/configMgr`.
2. Search for and configure the following:
    — Apache Sling GET Servlet: Ensure that JSON rendering is enabled.
    — Apache Sling Content Distribution: Configure the appropriate endpoints if necessary.

4. Create Content Services Configuration

1. Go to `http://localhost:4502/aem/start.html`.
2. Navigate to `Tools > General > Configurations`.
3. Create a new configuration for your content services.

5. Create a Content Fragment Model

1. Navigate to `http://localhost:4502/aem/start.html`.
2. Go to `Tools > Assets > Content Fragment Models`.
3. Create a new content fragment model, defining the necessary fields for your API.

6. Create Content Fragments

1. Navigate to `http://localhost:4502/aem/start.html`.
2. Go to `Assets > Files`.
3. Create a new content fragment using the model you defined.

7. Enable GraphQL

1. Navigate to the AEM Web Console at `http://localhost:4502/system/console/configMgr`.
2. Configure the Adobe Experience Manager GraphQL Service.

8. Test Your Setup

Access JSON Content:

1. Navigate to one of your content fragments in the Assets UI.
2. Click on the content fragment and check the JSON output by appending `.json` to the URL.

Access GraphQL Endpoint:

1. Go to `http://localhost:4502/api/graphql`.
2. Run a GraphQL query to fetch your content fragment data.

9. Develop and Test Your Application

You can now develop and test your headless application using the content served from AEM. Use tools like Postman to interact with your APIs and ensure they return the expected data.

10. Optimize and Secure Your AEM Instance

1. Optimize: Implement caching strategies and optimize the response times of your APIs.
2. Secure: Configure appropriate authentication mechanisms and ensure your APIs are secure.

By following these steps, you should have a functional AEM 6.5 Headless setup on your local machine. If you encounter any issues, the [AEM documentation](https://experienceleague.adobe.com/docs/experience-manager-65.html) is a valuable resource for troubleshooting and additional configurations.

Table of Contents

1. Prerequisites
2. Setting Up Solr

• Installing Solr
• Configuring Solr

3. Integrating Solr with AEM

• Configuring AEM to Use Solr
• Creating Solr Configuration Files

4. Indexing AEM Content in Solr

5. Implementing Search Functionality in AEM

6. Testing and Debugging

7. Advanced Configurations

8. Conclusion

1. Prerequisites

Before we begin, ensure you have the following:

• AEM installed (AEM 6.5 or newer is recommended)
• Solr installed (Solr 8.x is recommended)
• Basic knowledge of AEM, Java, and Apache Solr
• Administrative access to your AEM instance

2. Setting Up Solr

Installing Solr

1. Download Solr: Visit the official Solr website and download the latest version of Solr.
2. Install Solr:

tar xzf solr-8.11.1.tgz
cd solr-8.11.1
bin/solr start

Configuring Solr

1. Create a New Core: A core in Solr is a running instance that uses its own configuration. Create a new core named aemcore:

bin/solr create -c aemcore

2. Configure the Schema: Update the schema.xml file to define the fields and types Solr will index. Typically located in solr-8.11.1/server/solr/aemcore/conf/.

3. Integrating Solr with AEM

Configuring AEM to Use Solr

1. Install Solr Integration Package: Download and install the Solr integration package for AEM. You can find this on Adobe’s package share or AEM Solr Integration GitHub Repository.
2. Configure Solr Server in AEM:

• Navigate to AEM Web Console: http://localhost:4502/system/console/configMgr
• Search for Apache Solr Search
• Configure the Solr server details (URL, core name, etc.).

Creating Solr Configuration Files

1. Solr Configuration: Create or update solrconfig.xml and schema.xml files in the Solr core directory.
2. AEM Configuration: Update the org.apache.solr.client.solrj.impl.HttpSolrClient configuration in AEM to point to your Solr server.

4. Indexing AEM Content in Solr

1. Create an Indexing Service: Write an OSGi service in AEM to push content to Solr. Here is a sample code snippet:

@Component(service = IndexingService.class, immediate = true)
public class IndexingService {
    @Reference
    private HttpSolrClient solrClient;

    public void indexContent(Page page) {
        SolrInputDocument document = new SolrInputDocument();
        document.addField("id", page.getPath());
        document.addField("title", page.getTitle());
        // Add other fields as needed
        solrClient.add(document);
        solrClient.commit();
    }
}

2. Configure Event Listeners: Set up event listeners to trigger indexing when content is created or updated in AEM.

5. Implementing Search Functionality in AEM

1. Create a Search Servlet: Implement a servlet to handle search requests and query Solr.

@Component(
    service = { Servlet.class },
    property = {
        "sling.servlet.paths=/bin/search",
        "sling.servlet.methods=GET"
    }
)
public class SearchServlet extends SlingSafeMethodsServlet {
    @Reference
    private HttpSolrClient solrClient;

    @Override
    protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response) throws ServletException, IOException {
        String query = request.getParameter("q");
        SolrQuery solrQuery = new SolrQuery();
        solrQuery.setQuery(query);
        QueryResponse solrResponse = solrClient.query(solrQuery);
        // Process and return search results
    }
}

2. Create Search Components: Develop AEM components for the search form and results display using HTL and JavaScript.

6. Testing and Debugging

1. Test the Integration: Use AEM’s author and publish environments to test Solr integration.
2. Debugging: Check logs in AEM and Solr for any errors and ensure data is correctly indexed and searchable.

7. Advanced Configurations

1. Faceted Search: Configure Solr to support faceted search.
2. Synonym Handling: Add a synonyms.txt file in Solr to handle search synonyms.
3. Multilingual Support: Configure Solr and AEM to support multilingual content indexing and searching.

8. Conclusion

Integrating Solr with AEM can significantly improve the search experience on your site, offering faster and more relevant search results. This guide provided a step-by-step approach to setting up and configuring Solr with AEM, ensuring even beginners can follow along and implement a robust search solution.

For more details, you can refer to the following resources:

• Apache Solr Documentation
• Adobe Experience Manager Documentation
• AEM Solr Integration GitHub Repository

By following this guide, you’ll be well on your way to mastering Solr integration with AEM, providing your users with an exceptional search experience.

What is a Sling Model Exporter?

A Sling Model Exporter is a framework that enables the conversion of Sling Models into JSON. It uses annotations to define how a model can be exported and serialized, making it easier to share data with web services and JavaScript applications.

Setting Up Your AEM Project

Before you begin, ensure your AEM project is configured to use Sling Models and the Exporter framework. You’ll need to include the necessary dependencies in your pom.xml file and configure your Maven Bundle Plugin accordingly.

Creating Your First Sling Model with Exporter

Let’s create a simple Sling Model that can be exported as JSON.

package com.example.aem.models;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.Exporter;
@Model(adaptables = Resource.class)
@Exporter(name = "jackson", extensions = "json")
public class ExampleModel {
    @Inject
    private String title;
    // Standard getters and setters
}

In the above code snippet, we define a Sling Model ExampleModel that is adaptable from a Resource. We use the @Exporter annotation to specify that we want to export this model using Jackson to serialize it into JSON format.

Exporting the Model

To export the model, simply access the resource via HTTP request with the .json extension, and AEM will automatically use the Jackson exporter to serialize the model.

For example, if your model is associated with a resource at /content/example, you would access /content/example.model.json to get the JSON output.

Customizing the Export

You can further customize the JSON output using Jackson annotations. For example, you can use @JsonProperty to rename properties or @JsonIgnore to exclude certain properties from serialization.

package com.example.aem.models;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.Exporter;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonIgnore;
@Model(adaptables = Resource.class)
@Exporter(name = "jackson", extensions = "json")
public class CustomExampleModel {
    @Inject
    @JsonProperty("customTitle")
    private String title;
    @Inject
    @JsonIgnore
    private String internalId;
    // Standard getters and setters
}

In the CustomExampleModel, we’ve renamed the title property to customTitle in the JSON output and excluded the internalId property from serialization.

Sling Model Exporters in AEM are a robust way to expose your content as JSON or other formats. They provide a seamless integration between your AEM content repository and the consuming applications, enabling a more flexible and decoupled architecture.
Remember to test your models and exporters thoroughly to ensure the output is as expected. With the right setup, AEM Models with Exporter can significantly streamline your content delivery process.

I hope this blog post helps you understand AEM Models with Exporter.