RLTYis in the Non Fungible Tokens Industry

RLTY

rlty

React — redux for lazy developers. Part 2

Nonprofits tasked with shoring up the country’s supply of donated organs for transplant are overwhelmingly underperforming at their job, according to federal data released Friday, contributing to a national organ shortage. The data from the Centers for Medicare and Medicaid Services (CMS) is part of new standards for measuring performance meant to improve accountability in an industry laden with problems. It shows falling performance scores for the nonprofits, known as “organ procurement organizations,” based on the number of organ donors and resulting transplants compared with how many donors were possible. For 2021, just 15 of the nation’s 56 organizations were in the top-performing tier, a decline of five from the prior rankings. Another 18 were in the second tier—up by two—and must compete for their contracts during the next contract cycle. And 24, two more than in 2020, were in the lowest tier—some 42 percent of all organ procurement organizations. 42% of organ procurement organizations were ranked in the lowest performing tier in 2021 Such performance problems aren’t new, but until 2021, the nonprofits self-reported their results to regulators, making it impossible to compare them apples to apples. Agency oversight has ignored crucial parts of the delicate work of persuading families to donate their dying loved ones’ organs. It’s part of a track record of chronic opacity that has drawn congressional scrutiny and that experts and auditors say has contributed to the industry falling short by thousands of donations each year, up to 28,000 organs annually according to some advocates. Despite this, no organ procurement organization has lost its multimillion-dollar contract with CMS because of poor performance. The new performance standards use an external measure of how many donors were possible instead of having the procurement organizations self-report this. Because the measures have improved, a potential crackdown is looming: Organ procurement organizations that do not meet the new standards by 2024 are slated to either lose their contracts—if they’re found to be in the lowest performance tier—or compete to maintain them when that data is used in the 2026 recertification period. Even as they tighten performance reporting, though, regulators largely overlook a crucial part of the organ donation process: how exactly organ procurement organizations do their jobs. Documents obtained by The Markup and interviews with industry veterans show vast differences in performance standards, poor federal monitoring, and shortfalls in training. Regulators, for example, do not evaluate the procurement organizations on how often they show up to hospitals when called about a possible donor, how well they interact with families of the dying, or why they choose not to pursue someone for donation. Critics say CMS and other regulators should be more closely monitoring the nonprofits’ operations. “We are standing around in a dark room with a light switch,” said Brianna Doby, a health services researcher who previously consulted for organ procurement organizations. The organizations’ main trade group, the Association of Organ Procurement Organizations (AOPO), said the CMS measure is adequate for measuring performance. “The ultimate measure of the authorization process is whether an organ was donated and successfully transplanted, which is captured in the CMS metrics,” said Barry Massa, president of AOPO. CMS’s chief medical officer, Lee Fleisher, said CMS has requirements for how organ procurement organizations do their jobs as a condition for receiving payments from Medicare and Medicaid. But in the regulations it pointed The Markup to, many of the requirements included having established processes but not what the processes should be. Organ procurement organizations’ performance has long been a contentious subject, as performance varies widely across the close-knit industry. The new grading system from federal regulators is meant to address this; it measures how many donors each procurement organization had in a given year and how many transplants resulted, compared to a deaths metric provided by the Centers for Disease Control and Prevention for how many donors were possible. The data lags by about two years. AOPO sent an April 18 letter to Sen. Ron Wyden (D-Oregon) expressing concern over the large number of procurement organizations that would be decertified and the lack of a publicized process for how competition and decertification would work. Poor performance among the organizations has dogged the organ donation pipeline for years. One organ procurement organization, LiveOnNY, did such a poor job that its contract was nearly taken away twice. LiveOnNY’s chronically weak performance set the stage for hospitals in the area to form a lobbying group with hospitals in Massachusetts and a procurement organization in Los Angeles. The group recruited patients for a lawsuit that would allowed hospitals nationwide to obtain organs from a larger geographic area. (In published last month by The Markup and The Washington Post, we found that the new policy is itself and was orchestrated by a small group of executives, including organ procurement organization leaders.) an investigation riddled with problems The Markup obtained a 2019 audit of LiveOnNY’s performance as part of that investigation and is publishing it . below Credit:The Markup Caption: A 2019 audit of New York organ procurement organization LiveOnNY prepared by the Gift of Life Institute. The Markup retyped the document to help maintain the confidentiality of its source. Our version does not include appendices provided in the original document. LiveOnNY ranked in the lowest-performing tier for the most recent rankings. Who Gets to Donate The differences in how organ procurement organizations do their jobs begin long before their staff set foot in a hospital. Under federal law, hospitals must alert their local organ procurement organization to any potential candidate for organ donation. But it’s up to each nonprofit to decide, in consultation with the hospitals they serve, how to determine at what point a hospital should alert them. Federal regulations do not spell this out. These “clinical triggers” vary greatly. Organ procurement organizations and hospitals do not always publicize their triggers, but The Markup reviewed more than a dozen it found publicly posted or obtained from other sources. Loss of brainstem reflexes, such as whether someone’s pupils react to light, is a common requirement because it is used in diagnosing brain death—but how many of those reflexes must be lost depends on the nonprofit. Some require just one reflex to be absent, while others require two. Many use a scoring system for brain functionality called the that gives patients points based on their eye, verbal, and motor responses, but organ procurement organizations differ on what that score must be before hospitals alert them. Some don’t use this scoring system at all. Glasgow Coma Scale Requirements also vary on how quickly hospitals must inform organ procurement organizations about a potential donor. Many organizations require hospitals to call within an hour of someone meeting criteria for possible donation. Others let hospitals wait up to four hours. Waiting too long can mean a patient could die in a way that makes their organs unsuitable for donation. The organ procurement organizations are also responsible for communicating these standards clearly to the hospitals they work with, something that does not always happen. In the assessment of LiveOnNY that The Markup obtained, auditors found that “basic information about standards of practice or clinical triggers were requested but not made available” by LiveOnNY to hospital leaders. LiveOnNY did not respond to requests for comment. Unlike nearly all other areas of medicine, which clinical triggers produce the best donation outcomes isn’t rooted in years of evidence-based practice, according to people involved with organ procurement organizations. “There’s no research tied to it,” said Ginny McBride, CEO of Florida-based organ procurement organization OurLegacy. “It’s all observational.” OurLegacy ranked in the top performance tier in the most recent data. Staffing Whether a terminally ill or injured patient becomes an organ donor depends on the nature of their condition, but it also hinges on how staff at organ procurement organizations perform their duties. At the most basic level, staff need to quickly travel to hospitals in order to assess whether someone could be a donor and talk with that person’s family about the best course of action if they want to pursue donation. Not all organ procurement organizations have a good track record on this. The LiveOnNY audit, for example, found that LiveOnNY staff routinely failed to show up at hospitals when called. CMS does not assess why an organ procurement organization did not approach someone for donation. Among the most challenging parts of the job is talking with dying patients’ families. While CMS requires “discretion and sensitivity” for families’ beliefs around donation, the agency does not measure these crucial soft skills. And it’s up to each organ procurement organization to train its staff for these interactions. Some have specialized teams for this and other aspects of the donation process, while others have employees trained in a broader set of skills. LiveOnNY staff, for example, weren’t uniformly trained, auditors wrote in 2019, and many were so specialized it complicated the donation process. The audit also found that much of the training was done on the job and did not include “competency checks particularly as it relates to communication skills.” Staff in charge of getting authorization from families would delay approaching families because they were concerned about being denied, which “has certainly resulted in lost donation opportunities,” the audit found. There aren’t uniform requirements for degrees or training required to perform such work. Employees can obtain a Certified Procurement Transplant Coordinator certification, but this is voluntary in the industry and not required by all nonprofits. To help fill this gap, one university, the University of Toledo, offers a master’s degree in transplantation and donation sciences. The university offers both an in-person track for those looking to break into the field and an online track for those currently in the field looking to improve their skills in a particular area. What sets its training apart is standardization and training across the entire organ donation process, as opposed to specializing in a particular aspect such as approaching the family, Julie DeSantis, the university’s program director for transplant and donation sciences, said. Its graduates have been employed at dozens of organ procurement organizations across the country, according to its website. The transplantation program’s graduating classes are small, however—10 at most. Regulation To better measure the nonprofits’ performance, regulators would need to look at organ procurement organizations’ processes, not just their outcomes, some people close to the system said. “If we think the process is tightly connected to the outcome, figuring out where [there] are breakdowns in the procedure can help you improve the number of organs that are recovered,” Benjamin McMichael, health law professor at the University of Alabama, said. Some of this data is already in the hands of those that oversee organ procurement organizations. The United Network for Organ Sharing (UNOS) is the nonprofit that operates the federal transplant system under a federal contract. It has operated this system—the Organ Procurement and Transplantation Network—for nearly four decades. As part of its duties, it oversees organ procurement organizations. Nadine Hoffman, UNOS director of enterprise data management, said that UNOS does not have the power to “impose sanctions, including payment and decertification,” as CMS does. The procurement organizations are required to submit a form for every death that could have become a donation and for each “imminent neurological” death. The form, called the “death notification registration,” contains demographic information about the patient, when they were referred for donation, if they ended up donating, whether consent was obtained by the family, cause of death, and how they died, among other factors. This information could allow regulators to identify patterns in who isn’t pursued for donation and identify areas for improvement. UNOS does not use the information in this form to evaluate organ procurement organizations’ performance, Hoffman said. It shares the data collected through the form with the Health Resources and Services Administration, the branch of the U.S. Department of Health and Human Services that directly contracts with UNOS. Hoffman said that UNOS is “discussing whether it would be beneficial” for it to collect “different information—particularly now that CMS has established new metrics for determining [organ procurement organization] performance.” She did not elaborate on what information that might be. CMS does not receive data collected through the form, according to Fleisher, the agency’s chief medical officer. Instead the agency conducts its own surveys every four years to recertify the organ procurement organizations, mandating that internal protocols exist for evaluating and managing donors, time frames for donation, and interactions with families, among other requirements. CMS does not, however, set out what those protocols should be. It also requires data on topics including deaths, organs that weren’t recovered, consent for donation, and number of donors. The reality is we need to be held accountable to do our very best job. Diane Brockmeier, Mid-America Transplant The procurement organizations’ trade association, AOPO, previously conducted accreditation audits of the organizations that included greater specificity in some of these areas. It stopped in late 2021, the same year the new CMS performance standards were enacted. The death notification registration is missing measures that would allow regulators to look more closely at soft skills that greatly affect the donation process. CMS, the nonprofits’ main regulator, already has mechanisms in other areas of its oversight that could capture this. Families of hospice patients, for example, are required to fill out a survey that asks if the hospice workers kept them updated about their loved one’s care, listened to them, attended to them in a timely fashion, and treated their loved one with respect, rating the hospice center on a scale of zero to 10. Beyond that, six organ procurement organizations volunteered to open their books by sharing 10 years of such data with the Massachusetts Institute of Technology’s (MIT) Healthy ML Lab for analysis “to better understand where and how potential donors are lost, including by race and ethnicity,” according to the 2021 partnership announcement. The collaboration is still under way. McBride’s organization, OurLegacy, is one of the participating procurement organizations. LiveOnNY was but has since withdrawn, McBride said. previously part of the effort The data shared with MIT includes a vast amount of information about the intricacies of the organizations’ performance, including the time their nonprofits showed up at the hospital, when they approached a family, the family’s response, and when they started allocating organs. “Every decision we make, every action we take, is included in that database,” she said. AOPO, Massa said, “supports data sharing.” It is currently working on a data-sharing effort with an outside consultant “with the goal of increasing donation and transplantation rates” that includes information on “referrals, patient demographics, authorization, and organs recovered and transplanted.” It is not mandatory. Addressing these issues would require more transparency around this kind of organ procurement organization data and for regulators to use the data that is already collected. “The reality is we need to be held accountable to do our very best job,” said Diane Brockmeier, CEO of Missouri-based procurement organization Mid-America Transplant. It ranked in the top performance tier. “Patients deserve that.” By Malena Carollo Also published here Photo by on Nguyễn Hiệp Unsplash

The Nation’s Organ Donation Process Is Failing Because of This Crucial Link

এই গুরুত্বপূর্ণ লিঙ্কের কারণে জাতির অঙ্গ দান প্রক্রিয়া ব্যর্থ হচ্ছে

Der Organspendeprozess des Landes scheitert an dieser entscheidenden Verbindung

El proceso de donación de órganos del país está fallando debido a este vínculo crucial

Le processus national de don d’organes échoue à cause de ce lien crucial

इस महत्वपूर्ण कड़ी के कारण राष्ट्र की अंगदान प्रक्रिया विफल हो रही है

この重要なつながりのせいで、国の臓器提供プロセスは失敗している

국가의 장기 기증 과정은 이 결정적인 연관성 때문에 실패하고 있습니다

O processo nacional de doação de órgãos está falhando devido a este elo crucial

Национальный процесс донорства органов терпит неудачу из-за этого важного звена

Ülkenin Organ Bağışı Süreci Bu Önemli Bağlantı Nedeniyle Başarısız Oluyor

Quá trình hiến tạng của quốc gia đang thất bại vì liên kết quan trọng này

由于这个关键环节，国家的器官捐献过程失败了

Kaspresso is a powerful framework for automating the testing of mobile applications on the Android platform. One of the key features of Kaspresso is its user-friendly and intuitive architecture. Thanks to the modular approach, developers can easily customize and modify test scripts and take different approaches to creating test cases. Kaspresso libraries allow you to effectively interact with UI elements, perform actions, and test expected results. Thus, Kaspresso is an incredibly useful tool for and testers, which facilitates and speeds up the process of automating the testing of mobile applications on the Android platform. developers Kaspresso is based on and and provides a wide range of additional functions, such as: Espresso UI Automator Built-in protection against flaky tests Jetpack Compose support Screenshot testing with native approach (with dark mode support) Declarative approach for writing tests Ability to interact with other applications and system elements and interfaces Human readability with Kotlin DSL wrappers over UiAutomator and Espresso Detailed logs and reports (logs, view hierarchy, screenshots, video, etc.) ADB support Allure support Robolectric support Easy migration from Espresso Flexible configuration options Automatic artifacts pulling after test execution Significantly faster execution of UI Automator commands. With Kaspresso, some UI Automator commands run ! 10 times faster Page object pattern from the box Let's get started with the project. First, you need to add dependencies to the file: build.gradle androidTestImplementation 'com.kaspersky.android-components:kaspresso:1.5.3' For example, I’ll take a ready-made test Notes application. Where it will be possible to add, change, and delete notes. We will write the test in the folder androidTest We create the class and inherit it from . So, we follow the Page Object approach. MainScreen KScreen The Page Object approach implies that the modeled class will completely describe one screen of the application under test - all screen elements and methods for interacting with these elements. This way, we won't have to re-declar the same elements every time in our autotests. Next, we redefine and in our case, it is and : layoutId viewClass R.layout.activity_main MainActivity::class.java object MainScreen: KScreen<MainScreen>() {  
  
    private val buttonAddNote = KButton{ withId(R.id.add_button) }  
  
    fun clickAddNote(){  
        buttonAddNote.click()  
    }  
  
    override val layoutId: Int = R.layout.activity_main  
    override val viewClass: Class<*> = MainActivity::class.java  
  
} Kaspresso uses the convenient over to interact with elements provided by the Kakao library. Many ready-made wrappers have already been created for standard UI widgets. Let's use one of them to find a button - we need the class. We initialize it with a block, inside which we call a function to search for the widget using the of the desired button - . Kotlin DSL Espresso KButton id withId(R.id.add_button) Then, we create the method and add a call to the method on the element. clickAddNote click() Let's also add a test for the list of notes to . MainScreen object MainScreen: KScreen<MainScreen>() {  
  
    private val buttonAddNote = KButton{ withId(R.id.add_button) }
      
    val noteRv = KRecyclerView(  
        builder = { withId(R.id.notes_rv) },  
        itemTypeBuilder = { itemType(::NoteItem) }  
    )  
  
    fun clickAddNote(){  
        buttonAddNote.click()  
    }  
  
    override val layoutId: Int = R.layout.activity_main  
    override val viewClass: Class<*> = MainActivity::class.java  
  
    class NoteItem(matcher: Matcher<View>) : KRecyclerItem<NoteItem>(matcher) {  
  
        val deleteIcon = KImageView(matcher) { withId(R.id.delete_icon) }  
        val tvNoteTitle = KTextView(matcher) { withId(R.id.title_tv) }  
        val tvNoteText = KTextView(matcher) { withId(R.id.notes_tv) }  
  
    }  
} Added for interaction with . In KRecyclerView's builder, we determine by which id to find the . determines what elements our consists of. is our class which is used to describe a list item i.e. elements of View Holder. KRecyclerView RecyclerView RecyclerView itemTypeBuilder RecyclerView NoteItem Now, let's write a test for the adding a note screen. Here, we are already using the input field, and we need the class, to enter text we call the method. At the end, we call the method. The first time is needed to hide the keyboard, and the second time to close the screen, and when closing, notes are saved. KEditText typeText pressBack object NoteDetailScreen : KScreen<NoteDetailScreen>() {  
  
    private val titleEd = KEditText{ withId(R.id.title_et) }  
    private val noteEd = KEditText{ withId(R.id.note_et) }  
  
    fun inputNoteData(title: String, note: String) {  
        titleEd.typeText(title)  
        noteEd.typeText(note)  
        pressBack()  
		pressBack()
    }  
  
    override val layoutId: Int  
        get() = R.layout.fragment_notes_detail  
    override val viewClass: Class<*>  
        get() = NotesListFragment::class.java  
} We create by inheriting from and need to add a rule that provides control over the in the autotest. This is necessary to be able to interact with the interface of this activity in the application, in our case this is our main screen. NoteTest TestCase activity MainActivity class NoteTest : TestCase() {  
  
    @get:Rule  
    val activity = activityScenarioRule<MainActivity>()  
  
    @Test  
    fun noteTest() = run {  
  
        step("Navigate to add note screen") {  
            MainScreen.clickAddNote()  
        }  
  
        step("Add new note and back") {  
            NoteDetailScreen {  
                inputNoteData("Title first", "Note text")  
            }  
        }  
        step("Delete first note") {  
            MainScreen {  
                noteRv {  
                    childAt<MainScreen.NoteItem>(0) {  
                        tvNoteTitle.hasAnyText()  
                        tvNoteText.hasAnyText()  
                        deleteIcon.click()  
                    }  
                }            
            }        
        }    
    }
} Next, we create the noteTest method with the annotation. The first step is going to the page and adding a note. The next step is adding a new note using the method. The last step is to contact the RecyclerView and get the first element of the list, check whether the element has at least some text using the method, and at the end call to click. @Test NoteDetailScreen.inputNoteData hasAnyText deleteIcon Finally, we run the test and wait for the result! Links: Notes project with Kaspresso Kaspresso

Android Autotesting With Kaspresso

Verifiable Privacy-Preserving Computing: Conclusion & References

Today, I'm speaking with James Tagg, Chief Architect and Head of US Operations at World Mobile, and in this insightful interview, we'll talk about the transformative potential of Decentralized Wireless (DeWi) technology in rural America. We'll also look at how DeWi differs from traditional internet infrastructure, as well as the pressing challenges that both rural and suburban areas in the U.S. face regarding internet connectivity and how DeWi offers a promising solution to bridge the digital divide. So, let's get straight in! Hi there, please introduce yourself, and tell us what you do. I'm James Tagg, Chief Architect and Head of US Operations at World Mobile. Can you provide an overview of Decentralized Wireless (DeWi) technology and how it differs from traditional internet infrastructure? Well, to start with, it's not Internet infrastructure; what we do is mobile infrastructure. Decentralized Wireless (DeWi) technology focuses on providing mobile infrastructure to improve coverage, cost, and privacy. It can also complement wireless broadband to offer an alternative to fixed-line connectivity, particularly for hard-to-reach customers. Let's break it down. In the conventional scenario, mobile service providers establish extensive networks of towers to deliver mobile services to individual handsets and, in some cases, provide mobile broadband to homes through small building-mounted antennas. Large corporations centrally manage these networks with tens of thousands of employees and have a substantial cost base. DeWi, on the other hand, transforms this paradigm. Instead of relying on corporate giants, it empowers individuals and communities to take charge of their cellular connectivity needs. For instance, consider a farming community or a local village; rather than shelling out substantial fees to established telecom companies, they can install and manage their own cellular connectivity. This shift from centralized control to local, community-driven management is the essence of DeWi. DeWi enables smaller-scale, localized, and community-led mobile infrastructure deployment, breaking away from the traditional, top-down approach associated with large telecom companies. What are the main challenges rural areas in the U.S. face when it comes to internet connectivity, and how does DeWi address these challenges? Firstly, we should note, the issue isn't limited to rural areas alone. Take, for example, Silicon Valley or my own residence in San Diego. On my street, the six houses adjacent to mine lack quality wireless connectivity, meaning the mobile phone fails as you walk around the property and get into the car in the drive. Many normal use cases don't work, such as getting into the car while listening to a conference call. Additionally, only a single cable provider laid the cables more than three decades ago when the neighborhood was developed. The service is costly, and there is no competitive pressure. This situation persists despite being situated in a suburban environment. Extending this problem to rural regions makes it even more pronounced. Many villages and farming areas encounter similar challenges. Interestingly, even if you are just a short five-mile distance away from a major interstate, a common scenario in California, Nevada, and many other locations, you often find yourself without mobile connectivity and broadband access. What are the key components or technologies that make DeWi a promising solution for bridging the digital divide in rural America? Firstly, DeWi leverages the concept of community-driven infrastructure development, which proves to be a cost-effective approach. Rather than expending substantial sums on land acquisition and tower construction, communities contribute locations and land for deploying essential infrastructure like fiber optics. Furthermore, significant recent developments have reshaped the telecommunications landscape in the United States. The introduction of lightly licensed shared spectrum, such as the Citizens Broadband Radio Service (CBRS). This is a game-changer. In the past, large blocks of spectrum were auctioned, with mobile operators often spending millions to billions of dollars to acquire licenses from the FCC. In some European countries, the price tag could even reach $10 billion to secure national spectrum licenses. However, in the U.S., county-level licenses are available, albeit still costly, ranging from 2 to $10 million. What has truly transformed the situation is the availability of spectrum that can be obtained from the government for a mere $4 per month. This dramatic shift has opened new possibilities. World Mobile has obtained Band 71 licensed Spectrum and is pioneering a community-sharing approach. We manage the spectrum and its associated services for regulatory reasons, but the groundbreaking aspect is that anyone can set up their own antennas using this spectrum and our technology. Regular people or small businesses can expand network coverage for their specific area or community and become part of the collective network established by World Mobile. DeWi's ability to leverage community-driven infrastructure development and the introduction of licensed shared spectrum, such as CBRS, is revolutionizing the way rural America can access connectivity and bridge the digital divide. In terms of scalability and infrastructure, what are some of the considerations when implementing DeWi in rural areas with limited existing connectivity infrastructure? There are some key considerations When implementing DeWi in rural areas with limited existing connectivity infrastructure. First and foremost, establishing the foundational connectivity is paramount, typically involving installing fiber optics. A significant advantage we have at the moment is the commitment to fund the Broadband Equity Access and Deployment Program (BEAD), a bipartisan effort, to allocate $40 billion for the expansion of fiber networks to rural regions across America. This financial support greatly simplifies the process of launching DeWi initiatives, as it covers a substantial portion of the most costly aspect: installing fiber through trenching. What types of internet applications and services can benefit the most from improved connectivity in rural areas through Decentralized Wireless (DeWi)? Are there specific use cases that stand out? Improved connectivity in rural areas through DeWi primarily benefits applications and services that rely on high-quality internet access, with video content being a significant driver and constituting approximately 70% of internet traffic. Activities like video conferencing, education through content on platforms like YouTube, and similar interactive sessions like the one we're having now on this call. Without robust and consistent connectivity, these activities can be severely hampered. Other services, such as banking services, also benefit from reliable connectivity. Interruptions during online transactions can lead to data loss and inconvenience, for example, having to retype complex forms. As a result, individuals often avoid these tasks until they have access to a stable connection via a fixed-line connection. They do not get the advantages of online transactions if they don't have a stable connection. While all applications can benefit from improved connectivity, the most pronounced impact is observed in activities that require high bandwidth and stable interactivity. Conversely, basic tasks like asynchronous text messaging and email checking can generally function adequately on less robust connections. Of course, if you have no connectivity at all, then even the basic functions are unavailable. How does DeWi technology ensure reliability and stability of internet connectivity in remote and rural locations, which are often prone to environmental factors and infrastructure limitations? One significant advantage of DeWi lies in its community-driven management. In this model, the local community takes charge of the network, and if any issues arise, the person with the expertise to resolve them typically resides nearby. This contrasts with traditional infrastructure providers who might need to dispatch technicians from distant locations, causing delays in addressing connectivity problems. The proximity of those who care about the network's reliability enables quicker response and resolution. While DeWi faces similar challenges as traditional infrastructure in terms of maintenance and potential cable cuts, local ownership plays a pivotal role. As there are innovative solutions available within the community setting. For instance, a farmer we are testing with had implemented a meshing system that allows them to use cellular connections as a temporary relay if a cable is accidentally cut. This interim measure ensures that connectivity remains intact while repairs are being made. So, yes, there are tactics that you can use if you're in the community to simply reroute the traffic. In contrast, it could take two months for a large mobile service provider to reroute a signal. These practical, community-driven solutions are a testament to the agility and responsiveness that DeWi offers in addressing connectivity disruptions. How can community involvement and local empowerment play a role in successfully implementing Decentralized Wireless (DeWi) networks in rural areas? Local communities have a unique advantage in mobilizing resources and coordinating efforts effectively. When a community comes together to improve their connectivity, the process becomes considerably streamlined. In contrast, relying on a large corporation for such endeavors can result in lengthy, protracted projects that might span several years. In addition, local engagement fosters a sense of ownership and responsibility. When the community takes the lead in addressing their connectivity needs, the project tends to be more efficient and cost-effective. The difference in both timeline and budget can be substantial, with community-led initiatives often achieving results in a matter of months compared to the multi-year timescales associated with corporate-led efforts. In essence, community involvement and local empowerment not only expedite the implementation of DeWi networks in rural areas but also empower the residents, fostering a sense of control over their connectivity solutions. Are there any potential challenges or limitations that DeWi technology might face in rural areas, and how can these challenges be overcome? In a rural context, there's typically more groundwork than urban areas. You might need to establish basic infrastructure such as fiber and power sources. However, what distinguishes rural settings is the ease of overcoming these challenges. In rural areas, you can often directly engage with the landowners and seek permission to lay cables, which tends to be a straightforward process. These challenges are more complex when dealing with urban areas, with bureaucratic hurdles significantly slowing down progress. While rural contexts may demand more initial effort in terms of infrastructure setup, their advantage lies in the relative absence of bureaucratic complexities. This straightforward, community-focused approach is a key characteristic of DeWi technology, making it well-suited for bridging the digital divide in such areas. What are the potential economic and social impacts of improving internet connectivity in rural areas through Decentralized Wireless (DeWi)? How might it benefit these communities? DeWi's role in improving internet connectivity can drive economic growth, expand educational opportunities, and empower local businesses, fostering more vibrant and self-sustaining rural communities. Enhanced connectivity contributes to income growth and expanded economic opportunities. It allows residents in rural areas to access online job opportunities, engage in freelance work, and participate in e-commerce platforms, thereby increasing their overall income. Improved internet access also significantly influences education. Students in rural areas can access online learning resources, receive remote instruction, and engage in distance education programs, helping bridge the educational gap between rural and urban areas. Additionally, improved connectivity is advantageous for local businesses and entrepreneurs. With improved internet access, rural businesses can reach a larger market, reduce their reliance on middlemen, and then offer their products and services directly to consumers, resulting in increased profitability and the creation of new jobs within the community. Looking ahead, what do you envision as the future of connectivity in rural America with the continued development and adoption of Decentralized Wireless (DeWi) solutions? When envisioning the future of connectivity in rural America, one of the key prospects is that the community can gain ownership of its connectivity, enabling greater control, reduced costs, and increased flexibility compared to large, centralized infrastructures that often overlook the unique needs of rural economies. This shift is particularly important given the structural challenges in the U.S., where multiple carriers operate independently and are reluctant to share infrastructure. Consequently, serving a specific area might necessitate building multiple, redundant infrastructure networks, which is neither practical nor economically viable. Crucially, lower cost in this context does not imply lower quality. DeWi solutions can provide high-quality connectivity while embracing a community-driven approach where individuals come together, contribute resources, and build and maintain the network collaboratively. By sidestepping the bureaucratic and costly processes associated with traditional infrastructure development, DeWi empowers communities to take charge of their connectivity. In essence, the future of connectivity in rural America with DeWi solutions holds the promise of local ownership, cost-effectiveness, and community-driven collaboration to address the unique connectivity needs of rural areas, ensuring that more regions are covered and connected effectively.

Decentralized Wireless (DeWi): Closing the Rural-Urban Internet Gap in America

This will be a continuation of the article The Evolution of MV* Patterns in Android: Part 2 MVI MVI (Model-View-Intent) is an architectural pattern that is part of the Unidirectional Data Flow pattern family - an approach to system design in which everything appears as a unidirectional flow of actions and control states. Unlike MVVM, MVI assumes only one data source (single source of truth or SSOT). MVI consists of three components: logic, data, and state (Model); UI layer displaying the state (View) and intention(Intent). For example, if the user clicks on the “Respond to request” button, the click is converted into an event (Intent) necessary for the Model. In this formula, a request will be made to the server, the resulting result will update the screen state. The UI layer, in accordance with the new state, creates a button and displays text stating that the application has been sent. Let's move on to the example and the code. The example will show a simple method. Let's take an example from previous articles and the first thing we will write is states and events. sealed interface Event {  
  
    object FetchBooks: Event  
  
}  
  
sealed interface State {  
  
    object Loading: State  
  
    object Empty: State  
  
    data class Success(val books: List<Book> = emptyList()) : State  
  
    data class Error(val errorMessage: String)  
  
} Let's move on to the ViewModel. Here we will also use , but keep in mind that you can use Kotlin . LiveData Flow This is what the MainViewModel looks like now: class MainViewModel : ViewModel() {  
  
    private val booksRepository: BooksRepository = BooksRepositoryImpl()  
    private val _state = MutableLiveData<State>(State.Empty)  
    val state: LiveData<State>  
        get() = _state  
  
  
    fun event(event: Event) {  
        _state.value = State.Loading  
        when(event) {  
            Event.FetchBooks -> {  
                booksRepository.fetchBooks {  
                    if (it.isNotEmpty())  
                        _state.value = State.Success(books = it)  
                    else  
                        _state.value = State.Empty  
                }  
            }  
        }  
    }  
  
} Changed MainFragment: class MainFragment : Fragment(R.layout.fragment_main) {  
  
    private lateinit var booksRV: RecyclerView  
    private lateinit var progressBar: ProgressBar  
    private val adapter = BooksListAdapter()  
    private val mainViewModel: MainViewModel by viewModels()  
  
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {  
        super.onViewCreated(view, savedInstanceState)  
        booksRV = view.findViewById(R.id.books_rv)  
        progressBar = view.findViewById(R.id.progress_bar)  
  
        mainViewModel.event(Event.FetchBooks)  
        observeLiveData()  
    }  
  
    private fun observeLiveData() {  
        mainViewModel.state.observe(viewLifecycleOwner) { state ->  
            when(state) {  
                is State.Empty -> {  
                    progressBar.visibility = View.GONE  
                }  
                is State.Loading -> {  
                    progressBar.visibility = View.VISIBLE  
                }  
                is State.Success -> {   
                    progressBar.visibility = View.GONE  
                    adapter.submitList(state.books)  
                }  
                is State.Error -> {  
                    Toast.makeText(context, state.errorMessage, Toast.LENGTH_SHORT).show()  
                }  
            }  
        }  
    }  
  
    companion object {  
        @JvmStatic  
        fun newInstance() = MainFragment()  
    }  
  
} As a result, we have one input where events are processed and an output with a state. Pros State objects are immutable so it is thread-safe. All actions like state and event are in the same file so it is easy to understand what happens on the screen at one look. Maintaining state is easy. Since data flow is unidirectional, tracking is easy. Cons It causes a lot of boilerplate. High memory management because we have to create lots of object. Sometimes, we have many views and complicated logics, in this kind of situation become huge and we might want split this into smaller ones with extra instead of just using one. State State StateFlows

Evolution MV* Patterns in Android: Part 3

RISC-V is an open-source instruction set architecture (ISA) that has gained popularity due to its simplicity and flexibility. In this article, we’ll explore the fundamentals of RISC-V assembly language by building an assembler in C#. Our goal is to read RISC-V assembly code, identify the instruction type, and convert it into machine code. We’ll use Visual Studio as our development environment for this project. Setting Up the Project Let’s begin by creating a new project in Visual Studio. We’ll build our RISC-V assembler step by step. We mention that we will be building the assembler incrementally, and the first task is to set up a loop to read a file containing RISC-V assembly code and iterate over each line. This loop will serve as the foundation for processing the assembly code. string[] lines = File.ReadAllLines(filePath);

foreach (string line in lines)
{
  // Process the 'line' here, e.g., identify instruction type, parse, and convert to machine code
} Identifying Instruction Types RISC-V instructions are categorized into different types: R, U, I, B, S, and J. To determine the type of instruction, we’ll use a lookup table for opcodes, func2, and func7. You can find the lookup table in this . file Here’s an example of how to identify the instruction type: switch (opCode)
{
    case (OpCode)0b0110011:
        return InstructionType.R;
    case (OpCode)0b0010111:
        return InstructionType.U;
    case (OpCode)0b0110111:
        return InstructionType.U;
    case (OpCode)0b0010011:
        return InstructionType.I;
    case (OpCode)0b1100011:
        return InstructionType.B;
    case (OpCode)0b0000011:
        return InstructionType.I;
    case (OpCode)0b0100011:
        return InstructionType.S;
    case (OpCode)0b1101111:
        return InstructionType.J;
    default:
        return InstructionType.Unknown;
} You can find the implementation of this function in the file. RiscVAssembler.cs Parsing Instructions Now that we can identify the instruction type, let’s parse each instruction based on its type. We’ll start with the R-type instructions, which have the syntax: . op rd, rs1, rs2 For example, the instruction can be parsed as follows: add x10, x1, x2 Regex rTypeRegex = new Regex(@"^(\w+)\s+(\w+),\s+(\w+),\s+(\w+)$");
Match rTypeMatch = rTypeRegex.Match(instruction);
if (rTypeMatch.Success)
{
    return new RiscVInstruction
    {
        Instruction = instruction,
        Opcode = rTypeMatch.Groups[1].Value,
        Rd = rTypeMatch.Groups[2].Value,
        Rs1 = rTypeMatch.Groups[3].Value,
        Rs2 = rTypeMatch.Groups[4].Value,
        Immediate = null,
        InstructionType = InstructionType.R
    };
} You can find the complete implementation of the R-type instruction parser in the file. R_Parser.cs Converting to Machine Code Once we’ve parsed an instruction, we can convert it into machine code. Each instruction type has its own format. For R-type instructions, the format is as follows: R type: .insn r opcode6, func3, func7, rd, rs1, rs2
+-------+-----+-----+-------+----+---------+
| func7 | rs2 | rs1 | func3 | rd | opcode6 |
+-------+-----+-----+-------+----+---------+
31      25    20    15      12   7        0 For example, the instruction is translated into , where: add x10, x1, x2 00000000001000001000010100110011 Opcode 6: 0110011 Rd = 01010 Func 3 = 000 Rs1 = 00001 Rs2 = 00010 Func7 = 0000000 Here’s an example of how to convert the parsed instruction into machine code: string opcode = ((int)instruction.OpcodeBin).ToBinary(7);
string rdBinary = Convert.ToString(int.Parse(instruction.Rd.Substring(1)), 2).PadLeft(5, '0');
string func3 = ((int)instruction.Funct3).ToBinary(3);
string rs1Binary = Convert.ToString(int.Parse(instruction.Rs1.Substring(1)), 2).PadLeft(5, '0');
string rs2Binary = Convert.ToString(int.Parse(instruction.Rs2.Substring(1)), 2).PadLeft(5, '0');
string func7 = ((int)instruction.Funct7).ToBinary(7);

return new MachineCode($"{func7}{rs2Binary}{rs1Binary}{func3}{rdBinary}{opcode}", instruction.Instruction); You can find the complete implementation of machine code generation in the file. R_MachineCode.cs Conclusion In this article, we’ve embarked on a journey to learn RISC-V assembly language by building an assembler in C#. We’ve covered the basics of reading RISC-V assembly code, identifying instruction types, parsing instructions, and converting them into machine code. This project serves as a valuable learning experience for understanding the inner workings of RISC-V assembly language and its translation into machine code. To delve deeper into the RISC-V architecture, refer to the . RISC-V Specification Here’s the GitHub repository link for the project where you can find the code for building a RISC-V assembler in C#: . SharpRISCV GitHub Repository If you find the project helpful and informative, don’t forget to give it a star on GitHub to show your support. In the of our RISC-V assembly language learning series, we will explore , which are essential concepts for understanding and writing more complex assembly programs. Stay tuned for the next installment! next part addressing modes, labels, and offsets Also published . here

Understanding RISC-V Assembly Language by Building an Assembler in C#

This will be a continuation of the article: The Evolution of MV* Patterns in Android: Part 1 MVVM MVVM is also known as model-view-binder and was created by Microsoft architects Ken Cooper and John Gossman. Google I/O 2017 introduced architecture components that includes and which facilitates developing apps using the MVVM pattern. LiveData ViewModel Android This approach allows you to connect view elements with phenomena and events of the View model. It can be argued that each layer of this pattern does not know about the existence of another layer. The first and main difference is in the names of the business logic layers: in MVP and its derivatives, it is stored in the Presenter, while in MVVM, this role is played by the ViewModel. Secondly, this is the way the View layer and ViewModel interact. This is complicated by the fact that the obviously does not know about the layer, but still controls it. How can this be? More on this a little further. ViewModel View Layers of MVVM pattern are: This layer is responsible for the abstraction of the data sources. Model and ViewModel work together to get and save the data; Model: The purpose of this layer is to inform the ViewModel about the user’s action. This layer observes the ViewModel and does not contain any kind of logic; View: It exposes those data streams which are relevant to the View. Moreover, it serves as a link between the Model and the View; ViewModel: To implement MVVM, you will need to use or Kotlin , which precisely implements the principle of the Observer pattern and is also consistent with the lifecycle of the View. Learn more about working with events: LiveData Flow LiveData occurs simply through callbacks. View knows explicitly and stores a link to the , which allows us to use its methods. Listening to events ViewModel occur through or . We will always have the current value of our specific widget or the entire View layer on the View layer. Changes to the ViewModel MutableLiveData MutableStateFlow Example: ViewModel class MainViewModel : ViewModel() {  
  
    private val booksRepository: BooksRepository = BooksRepositoryImpl()  
    private val _booksLiveData = MutableLiveData<List<Book>>()  
    val bookLiveData: LiveData<List<Book>>  
        get() = _booksLiveData  
  
    private val _loadingLiveData = MutableLiveData<Boolean>()  
    val loadingLiveData: LiveData<Boolean>  
        get() = _loadingLiveData  
  
    fun fetchBooks() {  
        _loadingLiveData.value = true  
        booksRepository.fetchBooks {  
            _booksLiveData.value = it  
            _loadingLiveData.value = false  
        }  
    }  
} Repository interface BooksRepository {  
      
    fun fetchBooks(): List<Book>  
      
    fun saveInFavorites(id: Long): Boolean  
      
    fun removeFromFavorites(id: Long): Boolean  
      
}  
  
data class Book(val id: Long, val title: String, val author: String) MainFragment class MainFragment : Fragment(R.layout.fragment_main) {  
  
    private lateinit var booksRV: RecyclerView  
    private lateinit var progressBar: ProgressBar  
    private val adapter = BooksListAdapter()  
    private val mainViewModel: MainViewModel by viewModels()  
  
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {  
        super.onViewCreated(view, savedInstanceState)  
        booksRV = view.findViewById(R.id.books_rv)  
        progressBar = view.findViewById(R.id.progress_bar)  
  
        mainViewModel.fetchBooks()  
        observeLiveData()  
    }  
  
    private fun observeLiveData() {  
        mainViewModel.loadingLiveData.observe(viewLifecycleOwner) { value ->  
            value?.let {   
if (it) {  
                    progressBar.visibility = View.VISIBLE  
                } else {  
                    progressBar.visibility = View.GONE  
                }  
            }  
        }          
mainViewModel.bookLiveData.observe(viewLifecycleOwner) { value ->  
            value?.let {  
                adapter.submitList(it)  
            }  
        }    }  
  
    companion object {  
        @JvmStatic  
        fun newInstance() = MainFragment()  
    }  
  
} In conclusion With the right and experienced approach, MVVM simplifies the process of writing tests for code (due to fewer explicit connections), and it can be a slightly less verbose architecture than MVP and its derivatives.

The Evolution of MV Patterns in Android: Part 2

In this article, we will analyze the evolution of presentation patterns such as MVC(Model-View-Controller), [MVP](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93presenter#:~:text=Model%E2%80%93view%E2%80%93presenter%20(MVP,mostly%20for%20building%20user%20interfaces.&text=In%20MVP%2C%20the%20presenter%20assumes,is%20pushed%20to%20the%20presenter.)(Model-View-Presenter), MVVM(Model-View-ViewModel), MVI(Model-View-Intent). The problem of understanding the architectural approach in mobile development, in my opinion, lies in the abstractness of the architecture itself. Each developer has his own vision of how to correctly implement a particular pattern. And what are representation patterns for? structure the code and separate it into layers write maintainable and testable code Let's move on to what Model and View mean: is the data layer. Usually, it can be a and it talks to the database and the network. Model Repository is the display level. On Android, this would be , , or and should ideally be as dumb as possible. View Activity Fragment Custom View MVC This is the simplest pattern in , where the main business logic is contained in the Model class, and the View and Controller are implemented by the Activity and Fragment. Android Below is a diagram and sample code: Let's write our Repository: interface BooksRepository {  
      
    fun fetchBooks(): List<Book>  
      
    fun saveInFavorites(id: Long): Boolean  
      
    fun removeFromFavorites(id: Long): Boolean  
      
}  
  
data class Book(val id: Long, val title: String, val author: String) MVC release example: class MainFragment : Fragment(R.layout.fragment_main) {  
  
    private lateinit var booksRepository: BooksRepository  
    private lateinit var booksRV: RecyclerView  
    private val adapter = BooksListAdapter()  
  
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {  
        super.onViewCreated(view, savedInstanceState)  
        booksRV = view.findViewById(R.id.books_rv)  
          
        booksRepository.fetchBooks {  
            adapter.submitList(it)  
        }  
        }  
  
    companion object {  
        @JvmStatic  
        fun newInstance() = MainFragment()  
    }  
} Everything seems to be fine, but at first glance, over time, our code will grow and it will be difficult to maintain it. MainFragment And here there are certain disadvantages: difficult to write tests; code becomes more difficult to maintain over time; code is more difficult to read; MVP This approach allows you to create an abstraction of the view. To do this, you need to highlight the view interface with a specific set of properties and methods. The presenter, in turn, receives a reference to the implementation of the interface, subscribes to view events, and changes the model upon request. - a layer between View and Model. The View passes the events to it, and the Presenter passes them on, if necessary, calls the Model, and returns the data to the View for rendering. Presenter Presenter features: Two-way communication with the presentation; The View interacts directly with the Presenter by calling the appropriate functions or events of the Presenter instance; The Presenter interacts with the View by using a special interface implemented by the View; One Presenter instance is associated with one display; Cons Cyclic dependency between View and Presenter; The presenter provides methods to handle the View lifecycle; Bloated View interface; Difficulty maintaining state; MVP example. Creating the MainView interface: interface MainView {  
  
    fun setBooks(books: List<Book>)  
    fun showLoading()  
    fun hideLoading()  
    fun showError(message: String)  
  
} We create the MainPresenter class and pass it into the MainView constructor: class MainPresenter(private val view: MainView) {  
  
    private lateinit var booksRepository: BooksRepository  

	init {  
	    booksRepository = BooksRepositoryImpl()  
	}

    fun bind() {  
        view.showLoading()  
    }  
  
    fun fetchBooks() {  
        booksRepository.fetchBooks {  
            view.hideLoading()  
            view.setBooks(it)  
        }  
    }  
  
} And finally MainFragment: class MainFragment : Fragment(R.layout.fragment_main), MainView {  
  
    private lateinit var booksRV: RecyclerView  
    private lateinit var progressBar: ProgressBar  
    private val adapter = BooksListAdapter()  
    private lateinit var presenter: MainPresenter  
  
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {  
        super.onViewCreated(view, savedInstanceState)  
        booksRV = view.findViewById(R.id.books_rv)  
        progressBar = view.findViewById(R.id.progress_bar)  
  
        presenter = MainPresenter(this)  
        presenter.bind()  
        presenter.fetchBooks()  
    }  
  
    override fun setBooks(books: List<Book>) {  
        adapter.submitList(books)  
    }  
  
    override fun showLoading() {  
        progressBar.visibility = View.VISIBLE  
    }  
  
    override fun hideLoading() {  
        progressBar.visibility = View.GONE  
    }  
  
    override fun showError(message: String) {  
  
    }  
  
    companion object {  
        @JvmStatic  
        fun newInstance() = MainFragment()  
    }  
  
} What's going on? MainFragment, aka View, in the method, creates a Presenter instance and passes itself to the constructor. onViewCreated() Presenter, when created, explicitly receives a View and creates an instance of the Repository The Presenter accesses the Repository fetchBooks method. Repository receives and gives data to Presenter. Presenter calls View and passes the list of books

The Evolution of MV* Patterns in Android: Part 1

User Authentication in Android using Firebase (Java)

Autenticación de usuarios en Android usando Firebase (Java)

Authentification de l'utilisateur dans Android à l'aide de Firebase (Java)

फायरबेस (जावा) का उपयोग करके एंड्रॉइड में उपयोगकर्ता प्रमाणीकरण

Firebase (Java) を使用した Android でのユーザー認証

Autenticação do usuário no Android usando Firebase (Java)

Xác thực người dùng trong Android bằng Firebase (Java)

使用 Firebase (Java) 在 Android 中进行用户身份验证

This is our submission to . We hope you enjoy our first HackerNoon submission. Note: HackerNoon’s IP Geolocation Writing Contest In this article, we’ll be using ip2location, Shodan and other tools as case studies for discussing IP geolocation and privacy. We’ll also do a quick walk-through by showing you some suitable tools that you can easily use to determine information about systems as you browse the web. But first, let's get a quick rundown on our subject material from or as we call it – the electronic brain. Chat GPT Give me a quick synopsis on IP Geo-location and explain why we might need to know this information. Prompt: IP geolocation is the process of identifying the physical location of an internet-connected device by analyzing its IP address. Every device that is connected to the internet is assigned a unique IP address, which can be used to determine the approximate geographical location of the device. ChatGPT-generated Output: We might need to know this information for various reasons. For example, businesses can use IP Geo-location to target their advertising efforts to specific regions or countries. Law enforcement agencies can use IP Geolocation to track down cyber criminals or to locate missing persons. Website owners can use IP Geo-location to customize content based on the visitor's location. IP Geolocation can also be used to detect fraudulent activities such as identity theft, credit card fraud, and . By comparing the location of the device with the user's claimed location, suspicious activities can be flagged and prevented. phishing attacks Overall, IP Geo-location is a powerful tool that can provide valuable insights into the location of internet-connected devices. However, it's important to use this tool responsibly and to be aware of its limitations. That seems straightforward enough. We’d like to add 2 points, however. Firstly that IP location can be considered a form of open-source intelligence, or . Whilst the field of OSINT is quite broad, the general theme of the field is that it is based on information that is easily available to the public or “open source” in its nature. OSINT Secondly, whilst IP-lookup information is a useful tool for many purposes it’s important to understand that in a world  full of VPNs and proxy servers, the IP Lookup information you’re provided may link back to a VPN or proxy, guarding the user’s true IP against baseline detection. It’s important to know what to look for in determining if this is the case for a specific address of interest or not. Available Tools When searching, we can use three main tool types for geolocation. We can use the usual web portal through the browser, a browser-based extension, or a CLI / terminal-based interface. All systems have their own individual pros and cons and should be assessed accordingly however a good rule of thumb can be to use web-based or extension-based systems for beginners or scenarios that see lesser use, whilst terminal or command line interface options can be a better option for those more experienced users or those that prefer information without all the add-ons. If you’re not experienced with the terminal but would like to learn more, we’d like to remind you that we’re delivering a book at the start of next year that will walk you through exactly that. With tutorials on command line-based search, privacy-based browsing, and how to easily set up temporary email and sms facilities via the command line, Command Line for Investigators will take you through the steps you need to configure your Linux-based terminal for OSINT analysis. Web Based An example of this could be the portal provided by the competition sponsor, ip2location. Providing 50 free lookups a day without an account and more if you register for a free account, this is a simple easy way to determine information about individual IP addresses or address blocks without needing to provide registration information. If you’d like further features including the ability to save your search and interface them with CLI tools  then it’s worth signing up for an account to take advantage of these additional features. This isn’t essential however and can be used in a limited capacity within the browser straight away. Another web-based option is Shodan. Shodan, whilst being more in-depth, provides a larger field of search information including a myriad of search tags that allow you to search by country, device type and more. Unlike ip2location however, you’ll need to register for an account to make the best use of the service, so if you’re looking for a simple lookup, you may find ip2location to be a quicker option for you. If you need to check your own IP address to check that your VPN is working or see what your potential for fingerprinting is, whatismyipaddress.com will give you a lookup providing ipv4 and ipv6 addresses where relevant. Whilst not providing lookup information a worthy mention is the range of tools provided by the electronic frontier foundation. Giving you the ability to ensure https, check your browser fingerprint, and more, this is a worthwhile stop for any privacy advocate or budding OSINT investigator. You can find these at where you’ll see a number of these useful tools and extensions available for your use, free of charge. https://www.eff.org/pages/tools Browser Extensions You’ll also find some handy browser extensions that can run automatically and give you this information at your fingertips. If you’re a regular lookup user you may find this a better option than a dedicated web portal as it doesn’t require regular sign-in or pasting of address information. For Firefox users, the Flagfox extension will give you country of origin information in the address bar, with more information at a right-click available to the user. Pooling service information which includes custom configuration, Flagfox is a powerful yet simple tool when used correctly and is a good example of easily integrating these tools into your workflow. Shodan also has a browser extension that's used extensively. Providing IP information, server history, and location as well as port information, this extension also allows you to look up information on Shodan’s website, giving you the ability to conduct further searches with little input giving you a broader look at the address information. Working well for power uses, the Shodan lookup tool is good for basic analysis whilst providing further information to the users as required. Ip2location also provides users with a simple browser extension to provide lookup information. Whilst a simpler tool than the previously mentioned options, it’s still extremely useful for providing basic lookup information. You’ll find an Ip2location extension should be available for most of the common browsers. Terminal – CLI Based We’ve left terminal information for last as we feel this is a personal choice based on one’s preferences. Some people have no interest in using the command line, whilst others are experienced users, being able to do IP lookup and other networking enumeration. There are many well-known tools for gathering OSINT via the command line. However simplicity is best with a terminal, use it (or don’t) in a manner that compliments your workflow style. With that said, here are three tools that may be of interest to the new command line user. Whilst an install walk-through is outside the scope of this article you’ll find enough information online to assist you with installing these into your own setup along with active communities to assist you in troubleshooting should it be needed. It’s also worth checking GitHub for options as many tools and packages have been written to assist in simple searches. Remember to check the code closely before you run it, particularly if you are giving it sudo / admin rights to your machine. It’s up to the user to determine safe code, malware will always be out there. : In our opinion, the best way to use ip2location via the terminal is to simply use the provided inputs on the website.  You can also find provided code snippets using bash, PHP, Java, and even find simple curl requests to assist you in searching. Ip2Location ip2location.io Whilst you’ll need to register for an API key to get the best from the service, it’s a usable format, with a reasonable request limit on the free plan, and is even useful for beginner terminal users. Given that you can use it with something as simple as curl, you can start experimenting with this tool simply by looking at command or code snippets and running them in your own terminal. You can find more information on this at ip2location.io/ip2location-documentation : We have a familiar contender for number two, by including Shodan in our list of CLI-based tools. There's a reason why it deserved a mention in all three categories. Shodan is an extremely useful tool regardless of UI style. However, the command line version deserves a particular mention for working in a terminal as it provides a simple and effective way to collect and process domain, system, and user information in an easy-to-process format. Shodan It’s also a useful tool for beginners to start with, providing simple command inputs and an extensive help menu to guide you through the process, allowing you to obtain and learn useful inputs. You can even alias commands to shorten your search time or extract specific pieces of information. : Whilst not just a Geolocation tool we’ve given a particular nod to Recon-NG for its . With addable modules and good information and tutorials, Recon-NG can be used to provide a reasonably detailed picture of many open-source intelligence items of interest and can be configured to provide only relevant information to its user. Recon-NG configurability Whilst there is a technical penalty provided with learning and effectively using this tool, it’s a good option for terminal users to start with if for no other reason than taking the time to effectively use the CLI means you effectively have access to a vast range of tools within it, along with ways of collating and processing this acquired information efficiently. Install modules and learn as needed. You’ll be surprised at the configuration you’re able to achieve using freeware tools alone. Alias Your Bash / Use your history We’d be remiss to touch on terminal usage and not remind users of the ability of aliases to effectively reduce your workflow. Rather than typing and retyping common commands, you may find assigning commands an alias a much more effective way to conduct your OSINT. Whilst bash history, scripting, and other tools have their place, aliasing can also be an effective way of navigating your way through menus and accessing your command line resources efficiently. Plus, by configuring your own personalized aliases in your file you’ve taken the first steps towards effectively configuring your own terminals to be more personalized to suit your own circumstances. .bash_aliases If you’re a Linux user (and let’s face it, if you’re learning command line then you should be) why don’t you have a look at what else is in that file or your Is there anything else you’d like to customize, like your own greeting on startup, or a script to provide a random motivation. Perhaps you’d like to add neo-fetch so you can check out your system vitals and network information when the terminal opens. Maybe you can use a script to set up for search, logging into ip2location or shodan and providing your API key automatically each time the terminal opens. main .bashrc config file. Small mods like these are a great place to begin picking up little tips and tricks that will improve your ability to navigate the terminal and understand the Linux file and configuration system in a way that allows you to use it efficiently. Remember – master bash then take over the world….or something like that. In Closing So there you have it! Our first submission to the is now complete. HackerNoon writing contest We may look at a second submission that walks you through enumeration in some more detail depending on reader feedback. We’d like to remind people though, if you’re interested in learning in network resources and open source intelligence in general that there are a myriad of tools and solutions to assist you in your learning journey. Whilst it can be daunting taking on and learning a new topic there are many skilled bloggers and writers out there who enjoy breaking down these topics into ways that are easy for the beginner to follow. But the spirit of OSINT is following the information on a journey to where ever it goes. So don’t be afraid of using that flight tracker, or scouring GitHub for tools that interest you. Doing is still an effective way of learning. And if you’re people shy, don’t forget that we even live in a world where chat GPT is a very usable tool for tutoring. And in the interest of staying fair we’d like to finish by adding an affiliate link to an open source intelligence book that you may find useful in your pathways. We have no association with the author, and was not paid for any review or promotion. We’ve simply included additional study tools that we have both used and believe are worthy of peoples time and money. If you’d like to jump down the rabbit hole and put your own investigative skills to the test, these resources will give you all the information you need to make things happen and up your terminal game. Check out our book: Open Source Intelligence Techniques: Resources for Searching and Analyzing Online Information The lead image for this article was generated by HackerNoon's via the prompt "a map on a smartphone". AI Image Generator

IP Geolocation Tools for Beginners

নতুনদের জন্য আইপি জিওলোকেশন টুল

IP-Geolocation-Tools für Anfänger

Herramientas de geolocalización IP para principiantes

Outils de géolocalisation IP pour débutants

नौसिखियों के लिए आईपी जियोलोकेशन उपकरण

初心者向け IP ジオロケーション ツール

초보자를 위한 IP 위치정보 도구

Ferramentas de geolocalização IP para iniciantes

Yeni Başlayanlar İçin IP Konum Belirleme Araçları

Công cụ định vị địa lý IP cho người mới bắt đầu

初学者 IP 地理定位工具

THE ROTIFERS

142 Stories To Learn About Angular

FROBISHER IN ARCTIC AMERICA

Around half a year ago I decided to start decorating my new house. Before getting started, I did lots of research on a variety of different topics relating to interior decoration, such as how to choose a consistent color scheme, which measurements to make and how to make them, and how to choose the right furniture. However, my preparations made me realize that no matter how well prepared you are, you're always going to run into many unexpected challenges. Before rushing to the furniture store, I listed all the different pieces of furniture that I wanted to place in my living room, including a sofa, tea table, potted plants, dining table, and carpet, and determined the expected dimensions, colors, and styles of these various items of furniture. However, when I finally got to the furniture store, the dizzying variety of choices had me confused, and I found it very difficult to imagine how the different choices of furniture would actually look like in actual living room. At that moment a thought came to my mind: wouldn't it be great if there was an app that allows users to upload images of their home and then freely select different furniture products to see how they'll look like in their home? Such an app would surely save users wishing to decorate their home lots of time and unnecessary trouble, and reduce the risks of users being dissatisfied with the final decoration result. That's when the idea of developing an app by myself came to my mind. My initial idea was to design an app that people could use to help them quickly satisfy their home decoration needs by allowing them see what furniture would look like in their homes. The basic way the app works is that users first upload one or multiple images of a room they want to decorate, and then set a reference parameter, such as the distance between the floor and the ceiling. Armed with this information, the app would then automatically calculate the parameters of other areas in the room. Then, users can upload images of furniture they like into a virtual shopping cart. When uploading such images, users need to specify the dimensions of the furniture. From the editing screen, users can drag and drop furniture from the shopping cart onto the image of the room to preview the effect. But then a problem arises: images of furniture dragged and dropped into the room look pasted on and do not blend naturally with their surroundings. By a stroke of luck, I happened to discover when looking for a solution for the aforementioned problem. This development kit provides the ability to integrate virtual objects realistically into the real world, which is exactly what my app needs. With its plane detection capability, my app will be able to detect the real planes in a home and allow users to place virtual furniture based on these planes; and with its hit test capability, users can interact with virtual furniture to change their position and orientation in a natural manner. HMS Core AR Engine Next, I'd like to briefly introduce the two capabilities this development kit offers. AR Engine tracks the illumination, planes, images, objects, surfaces, and other environmental information, to allow apps to integrate virtual objects into the physical world and look and behave like they would if they were real. Its plane detection capability identifies feature points in groups on horizontal and vertical planes, as well as the boundaries of the planes, ensuring that your app can place virtual objects on them. In addition, the kit continuously tracks the location and orientation of devices relative to their surrounding environment, and establishes a unified geometric space between the virtual world and the physical world. The kit uses its hit test capability to map a point of interest that users tap on the screen to a point of interest in the real environment, from where a ray will be emitted pointing to the location of the device camera, and return the intersecting point between the ray and the plane. In this way, users can interact with any virtual object on their device screen. Functions and Features Plane detection: Both horizontal and vertical planes are supported. Accuracy: The margin of error is around 2.5 cm when the target plane is 1 m away from the camera. Texture recognition delay: < 1s Supports polygon fitting and plane merging. Development Procedure (Plane Detection) Create a object. This example demonstrates how to use the world AR scenario of AR Engine. WorldActivity Public class WorldActivity extends BaseActivity{
Protected void onCreate (Bundle saveInstanceState) {
Initialize DisplayRotationManager.
  mDisplayRotationManager = new DisplayRotationManager(this);
Initialize WorldRenderManager.
     mWorldRenderManager = new WorldRenderManager(this,this);
}
// Create a gesture processor.
 Private void initGestureDetector(){
mGestureDetector = new GestureDetector(this,new GestureDetector.SimpleOnGestureListener()){
  }
 }
 mSurfaceView.setOnTouchListener(new View.OnTouchListener()){
  public Boolean onTouch(View v,MotionEvent event){
   return mGestureDetector.onTouchEvent(event);
  }
 }
// Create ARWorldTrackingConfig in the onResume lifecycle.
 protected void onResume(){
  mArSession = new ARSession(this.getApplicationContext());
  mConfig = new ARWorldTrackingConfig(mArSession);
  …
}
// Initialize a refresh configuration class.
private void refreshConfig(int lightingMode){
// Set the focus.
 mConfig.setFocusMode(ARConfigBase.FocusMode.AUTO_FOCUS);
 mArSession.configure(mConfig);
}
} 2) Initialize the class, which manages rendering related to world scenarios, including label rendering and virtual object rendering. WorldRenderManager public class WorldRenderManager implements GLSurfaceView.Renderr{
// Initialize a class for frame drawing.
 Public void onDrawFrame(GL10 unused){
// Set the openGL textureId for storing the camera preview stream data.
mSession.setCameraTextureName(mTextureDisplay.getExternalTextureId());
// Update the calculation result of AR Engine. You are advised to call this API when your app needs to obtain the latest data.
ARFrame arFrame = mSession.update();
// Obtains the camera specifications of the current frame.
ARCamera arCamera = arFrame.getCamera();
// Returns a projection matrix used for coordinate calculation, which can be used for the transformation from the camera coordinate system to the clip coordinate system.
arCamera.getProjectionMatrix(projectionMatrix, PROJ_MATRIX_OFFSET, PROJ_MATRIX_NEAR, PROJ_MATRIX_FAR);
Session.getAllTrackables(ARPlane.class)
...
 }
} 3) Initialize the class, which provides properties of the virtual object and the necessary methods for rendering the virtual object. VirtualObject Public class VirtualObject{
} 4) class to draw virtual objects based on specified parameters. Initialize the tDisplay Objec Public class ObjectDisplay{
} Development Procedure (Hit Test) Initialize the class, which manages rendering related to world scenarios, including label rendering and virtual object rendering. WorldRenderManager public class WorldRenderManager implementsGLSurfaceView.Renderer{
// Pass the context.
 public WorldRenderManager(Activity activity, Context context) {
  mActivity = activity;
       mContext = context;
  …
}
// Set ARSession, which updates and obtains the latest data in OnDrawFrame.
public void setArSession(ARSession arSession) {
        if (arSession == null) {
            LogUtil.error(TAG, "setSession error, arSession is null!");
            return;
        }
        mSession = arSession;
 }
// Set ARWorldTrackingConfig to obtain the configuration mode.
public void setArWorldTrackingConfig(ARWorldTrackingConfig arConfig) {
        if (arConfig == null) {
LogUtil.error(TAG, "setArWorldTrackingConfig error, arConfig is null!");
            return;
        }
        mArWorldTrackingConfig = arConfig;
    }
// Implement the onDrawFrame() method.
@Override
public void onDrawFrame(GL10 unused) {
 mSession.setCameraTextureName(mTextureDisplay.getExternalTextureId());
ARFrame arFrame = mSession.update();
ARCamera arCamera = arFrame.getCamera();
...
}
// Output the hit result.
private ARHitResult hitTest4Result(ARFrame frame, ARCamera camera, MotionEvent event) {
   ARHitResult hitResult = null;
   List<ARHitResult> hitTestResults = frame.hitTest(event);
// Determine whether the hit point is within the plane polygon.
ARHitResult hitResultTemp = hitTestResults.get(i);
            if (hitResultTemp == null) {
                continue;
            }
ARTrackable trackable = hitResultTemp.getTrackable();
// Determine whether the point cloud is tapped and whether the point faces the camera.
  boolean isPointHitJudge = trackable instanceof ARPoint
&& ((ARPoint) trackable).getOrientationMode() == ARPoint.OrientationMode.ESTIMATED_SURFACE_NORMAL;
// Select points on the plane preferentially.
if (isPlanHitJudge || isPointHitJudge) {
      hitResult = hitResultTemp;
      if (trackable instanceof ARPlane) {
                break;
             }
      }
return hitResult;
}
} 2) Create a object. This example demonstrates how to use the world AR scenario of AR Engine. WorldActivity public class WorldActivity extends BaseActivity {
 private ARSession mArSession;
private GLSurfaceView mSurfaceView;
private ARWorldTrackingConfig mConfig;
@Override
protected void onCreate(Bundle savedInstanceState) {
  LogUtil.info(TAG, "onCreate");
       super.onCreate(savedInstanceState);
       setContentView(R.layout.world_java_activity_main);
 mWorldRenderManager = new WorldRenderManager(this, this);
mWorldRenderManager.setDisplayRotationManage(mDisplayRotationManager);
mWorldRenderManager.setQueuedSingleTaps(mQueuedSingleTaps)  
}
@Override
protected void onResume() {
 if (!PermissionManager.hasPermission(this)) {
            this.finish();
        }
        errorMessage = null;
        if (mArSession == null) {
            try {
                if (!arEngineAbilityCheck()) {
                    finish();
                    return;
                }
                mArSession = new ARSession(this.getApplicationContext());
                mConfig = new ARWorldTrackingConfig(mArSession);
                refreshConfig(ARConfigBase.LIGHT_MODE_ENVIRONMENT_LIGHTING | ARConfigBase.LIGHT_MODE_ENVIRONMENT_TEXTURE);
            } catch (Exception capturedException) {
                setMessageWhenError(capturedException);
            }
            if (errorMessage != null) {
                stopArSession();
                return;
            }
}

@Override
    protected void onPause() {
        LogUtil.info(TAG, "onPause start.");
        super.onPause();
        if (mArSession != null) {
            mDisplayRotationManager.unregisterDisplayListener();
            mSurfaceView.onPause();
            mArSession.pause();
        }
        LogUtil.info(TAG, "onPause end.");
    }
@Override
    protected void onDestroy() {
        LogUtil.info(TAG, "onDestroy start.");
        if (mArSession != null) {
            mArSession.stop();
            mArSession = null;
        }
        if (mWorldRenderManager != null) {
            mWorldRenderManager.releaseARAnchor();
        }
        super.onDestroy();
        LogUtil.info(TAG, "onDestroy end.");
    }
...
} Summary If you've ever done any interior decorating, I'm sure you've wanted the ability to see what furniture would look like in your home without having to purchase them first. After all, most furniture isn't cheap and delivery and assembly can be quite a hassle. That's why apps that allow users to place and view virtual furniture in their real homes are truly life-changing technologies. HMS Core AR Engine can help greatly streamline the development of such apps. With its plane detection and hit test capabilities, the development kit enables your app to accurately detect planes in the real world, and then blend virtual objects naturally into the real world. In addition to virtual home decoration, this powerful kit also has a broad range of other applications. For example, you can leverage its capabilities to develop an AR video game, an AR-based teaching app that allows students to view historical artifacts in 3D, or an e-commerce app with a virtual try-on feature.

I Decorated My House Using AR: Here's How I Did It

SCIENCE AND RELIGION AT ALEXANDRIA

Git is difficult. On top of that, for many new developers, it’s the first tool with a command line interface (CLI) that they use. It can be a bit too much if you’re learning all the following at the same time: how to use CLI how to use Git and last but not least: programming In this article, I’ll show you a few tricks to make your Git experience less painful and more fun! Check your state Git is generous enough to offer many commands to check the state of your repository, yet prudent enough not to overwhelm the beginner with verbosity. In short—you should ask Git to give you the details you need. You have following command for it: git status A key command to get a glimpse of where you are in Git. Example outputs: $ git status
On branch main
Your branch is up to date with 'origin/main'.

nothing to commit, working tree clean for when you are on clean branch and up to date $ git status
HEAD detached at abc01e7
nothing to commit, working tree clean for when you are in . detached HEAD state $ git status
On branch main
Your branch is up to date with 'origin/main'.

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        lorem-ipsum.txt

nothing added to commit but untracked files present (use "git add" to track) When you have some new files in your working copy. git show This is a command that allows you to see changes that happened in a commit. When run without an argument, it shows you the current commit: $ git show
commit abc01e761cb9cc14c4d5aecae2488810c834c0f9 (HEAD -> main, origin/main, origin/HEAD)
Author: Marcin Wosinek <marcin.wosinek@gmail.com>
Date:   Wed Nov 2 11:57:33 2022 +0100

    Add lorem ipsum to readme

diff --git a/README.md b/README.md
index 8ae0569..9dca8b4 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,2 @@
 # Test
+Lorem ipsum You get all the details about the commit: its author, time, message and diff of each file that was changed. You can specify any commit you want to see: $ git show edd3504
commit edd3504f6edc722482fa4383443fa1729acc9a87
…rest of the output… Note! This command works on . Thus, if you use branch name, it will show the most recent commit from that branch: commits $ git show main
commit abc01e761cb9cc14c4d5aecae2488810c834c0f9 (HEAD -> main, origin/main, origin/HEAD)
Author: Marcin Wosinek <marcin.wosinek@gmail.com> —a custom alias I recommend to everybody git tree I recommend defining a tree alias to see the graph of all the branches—you can learn more about it in this . With it in place, you can run: article $ git tree
* 11f7f3c (test) add test.txt file
| * 2dbd30f (origin/test) add test.txt file
| * e7be203 (test-2) add new file
|/
* abc01e7 (HEAD -> main, origin/main, origin/HEAD) Add lorem ipsum to readme
* edd3504 Add readme And get a nice overview of the entire repository. Check what your default editor is In some cases, Git wants you to provide input to it by editing a temporary file it created. This workflow can be confusing at first, and even more so if you don’t know your default editor. Here’s how to check it by listing Git’s logical variables and filtering them to the one that contains . On my MacOS, it’s : EDITOR vi $ git var -l | grep EDITOR
GIT_EDITOR=vi Similarly, on Ubuntu: $ git var -l | grep EDITOR
GIT_EDITOR=editor On Ubuntu, is a command that starts what is configured as your default text editor. One machine I have access to, it’s : editor nano $ update-alternatives --display editor
editor - auto mode
  link best version is /bin/nano
  link currently points to /bin/nano
… No matter your editor, make sure you know how to do the following things: edit the file—which can be challenging for beginners in , due to the various modes of its interface Vim save the changes exit the editor Or, change the editor to something you know how to use. Use tab while typing commands Git commands, all the attributes, and branch names are long; and the interface accepts no mistakes. The key productivity trick is not to type them whole. In most shells, when you press tab key, the shell either: shows you all available command auto completes picks command if there is only one available So, for example, with the shell I use, let’s see these options after typing : zsh git co<tab> $ git co
Completing main porcelain command
commit        -- record changes to repository
Completing ancillary manipulator command
config        -- get and set repository or global options
Completing ancillary interrogator command
count-objects -- count unpacked objects and display their disk consumption
Completing plumbing manipulator command
commit-graph  -- write and verify Git commit-graph files
commit-tree   -- create new commit object
Completing plumbing internal helper command
column        -- display data in columns And just complete the word when I type : git com<tab> $ git commit Similarly, it provides autocomplete for parameters, branch names, etc. It makes a big difference while typing. Use arrows Watching someone retype the whole command they used a few moments ago is a painful experience. Most shells allow you to reuse the last command by just using arrow keys. Arrow up brings the most recent command, you type it again to get the previous one, and so on. After finding the one you need, you can edit it to match the operation you’re performing right now. Get remote changes all the time I sync my local repository with remote all the time—even in my private repos, where I know, I’m working alone. It’s too easy to mess up stuff by not paying attention to what others are changing. And it takes only one command to make sure everything is up to date: $ git fetch After running it, you know that every reference you see locally is in the same place as it is on remote. origin/<branch-name> Start your new branches from the updated main Conflicts are sometimes painful to fix, but nothing hurts more than conflicts that could have been easily avoided. One of the common scenarios when people introduce an unnecessary conflict, is when they start a new branch behind the most recent commit. This can be easily avoided by: doing fetch all the time paying attention to where in the history tree you are Short-lived branches Having branches that are merged quickly has a few benefits: New features are integrated sooner into the codebase. If they are not completely ready, they can always be hidden by a feature flag. Fewer changes in both the main and another branch mean there is less risk of conflicts. Smaller branches mean less code to review. Short-lived branches are a way to progress via small interactions—something I recommend in . another article Things to avoid I often see beginners coming with problems I mostly don’t have to deal with because I avoid the following things in Git: git pull In Git, pull combines two operations into one: , and git fetch or Depending on your configuration git merge git rebase I always want to double-check my remote state doing either merge or rebase. So my typical flow would be: before —to get updates from remote, git fetch —the alias I mentioned above, to make sure the repo is in the state I expect it to be, git tree —when there are changes remote and locally, or git rebase origin/<branch-name> `git merge origin/—when there are changes on remote but not locally. That is, it can be done as a fast-forward merge. Git submodules Finally, submodules are a way of embedding a Git repository or repositories inside another. The internal repository maintains its separate history, whereas the containing one keeps only the reference to the origin and the current commit that the internal repo should be at. My main issue with Git submodules is that they complicate an already difficult problem—version control—and add more layers of complexity. Git submodules provide an alternative solution for the problem that is better addressed with: using some package manager (like npm) for external dependencies merging multiple repositories into one for internal dependencies What’s next Git has many confusing aspects, but it gets way simpler once you understand it. If you are interested in learning more about Git, sign up to get updates about my Git-focused content. here Originally published here.

A Guide to Staying Sane While Working with Git  

In this article, we will analyze the interesting points of the Fragment API, I think that it will be of interest to all developers who develop an application for Android. First, you need to add dependencies: dependencies {    
	def fragment_version = "1.5.4"
	implementation "androidx.fragment:fragment-ktx:$fragment_version"
} Fragment-ktx FragmentManager Now you can describe transactions in a DSL style and the functions and or are called under the hood: beginTransaction() commit() commitAllowStateLoss() fun FragmentManager.commit(
  allowStateLoss: Boolean = false, 
  block:  FragmentTransaction.() -> Unit
) Example: fragmentManager.commit {
  // transaction
} FragmentTransaction Added replacement for method overloads. A similar extension has been added for : FragmentTransaction.add(Int, Class<out Fragment>, Bundle?) FragmentTransaction.replace() fun <reified T: Fragment> FragmentTransaction.add(
  containerId: Int, 
  tag: String? = null, 
  args: Bundle? = null
): FragmentTransaction

fun <reified T: Fragment> FragmentTransaction.replace(
  containerId: Int, 
  tag: String? = null, 
  args: Bundle? = null
): FragmentTransaction Example: fragmentManager.commit {
  val args = bundleOf("key" to "value")
  add<FragmentA>(R.id.fragment_container, "tag", args)
  replace<FragmentB>(R.id.fragment_container)
} Transaction optimization Optimization is a pretty important thing. To figure out how FragmentManager can do everything for us, let's try to optimize transactions by hand. fragmentManager.commit {
  add<FragmentA>(R.id.fragment_container)
  replace<FragmentB>(R.id.fragment_container)
  replace<FragmentC>(R.id.fragment_container)
} How to speed up a transaction? During the most complex technical analysis, we see that, following its results, the user will see . We are simple people and just throw out the extra two actions, immediately showing . Another example is with two transactions running one after the other: FragmentC FragmentC // 1
fragmentManager.commit {
  add<FragmentA>(R.id.fragment_container)
}

// 2
fragmentManager.commit {
  replace<FragmentB>(R.id.fragment_container)
} In this case, we could abort the addition of and immediately add . We cannot do this, but the problem is rather theoretical. All of the above FragmentManager can do on its own. We just need to allow it by adding to the transaction we want to optimize. FragmentA FragmentB setReorderingAllowed(true) fragmentManager.commit {
  setReorderingAllowed(true)
  add<FragmentA>(R.id.fragment_container)
  replace<FragmentB>(R.id.fragment_container)
  replace<FragmentC>(R.id.fragment_container)
} In the second place, you need to set the focus in the first place, because it is her permission to interrupt, and the second, in turn, must be fully controlled: // 1
fragmentManager.commit {
  setReorderingAllowed(true)
  add<FragmentA>(R.id.fragment_container)
}

// 2
fragmentManager.commit {
  replace<FragmentB>(R.id.fragment_container)
} In fact, we allow the to behave lazily and not execute unnecessary commands, which gives some performance gain. Moreover, it helps to handle animations, transitions, and back stack correctly. FragmentManager It is worth remembering that an optimized can: FragmentManager do not create a fragment if it is replaced in the same transaction; interrupt the life cycle at any time before , if a transaction to replace the added fragment has begun; RESUMED cause of the new fragment to be called before of the old one. onCreate() onDestroy() During a transaction, there are several ways to manage the life cycle of a fragment, in some cases, this may be useful. Change visibility We can hide and show a fragment without changing its lifecycle state. This behavior is similar to and . View.visibility = View.GONE View.visibility = View.VISIBLE We can just hide the container. This is true, but hiding the container in the back stack will not work, and a transaction with a similar command is easy. To hide a fragment from prying eyes, just call the method: FragmentTransaction.hide(Fragment) fragmentManager.commit {
  setReorderingAllowed(true)
  fragmentManager.findFragmentById(R.id.fragment_container)?.let {  
    hide(it) 
  }
} To show it again, you need to call the method: FragmentTransaction.show(Fragment) fragmentManager.commit {
  setReorderingAllowed(true)
  fragmentManager.findFragmentById(R.id.fragment_container)?.let { 
    show(it) 
  }
} Destroying the View We can destroy the Fragment's View, but not the itself, by calling the method. As a result of such a transaction, the fragment will enter the state: Fragment FragmentTransaction.detach(Fragment) STOPPED fragmentManager.commit {
  setReorderingAllowed(true)
  fragmentManager.findFragmentById(R.id.fragment_container)?.let { 
    detach(it) 
  }
} To recreate the Fragment View, just call the method: FragmentTransaction.attach(Fragment) fragmentManager.commit {
  setReorderingAllowed(true)
  fragmentManager.findFragmentById(R.id.fragment_container)?.let { 
    attach(it) 
  }
} FragmentFactory In Fragments 1.1.0, we can control the creation of fragment instances, including adding any parameters and dependencies to the constructor. To do this, it is enough to replace the standard implementation of with our own, where we are our kings and gods. FragmentFactory fragmentManager.fagmentFactory = MyFragmentFactory(Dependency()) The main thing is to have time to replace the implementation before the needs it, that is, before the first transaction and restoring the state after re-creation. The sooner we replace the bad implementation, the better. FragmentManager For Activity, the best scenario would be to replace: before ; super.onCreate() in the block. init Fragments do not immediately have access to their . Therefore, we can only perform the substitution between and inclusive, otherwise, we will see terrible red text in the logs after launch. FragmentManager onAttach() onCreate() But it's important to remember that is the through which the commit was made. parentFragmentManager FragmentManager Therefore, if you previously replaced in it, you do not need to do this a second time. FragmentFactory Now let's figure out how we can implement our factory. We create a class, inherit from , and override the method. FragmentFactory instantiate() class MyFragmentFactory(
  private val dependency: Dependency
) : FragmentFactory() {
  
  override fun instantiate(classLoader: ClassLoader, className: String): Fragment {
    return when(className) {
      FirstFragment::class.java.name -> FirstFragment(dependency)
      SecondFragment::class.java.name -> SecondFragment()
      else -> super.instantiate(classLoader, className)
    }
  }
} We get a as input, which can be used to create a , and is the full name of the desired fragment. We determine which fragment we need to create and return based on the name. If we do not know such a fragment, we transfer control to the parent implementation. classLoader Class<out Fragment> className This is what looks like under the hood of : super.instantiate() FragmentFactory open fun instantiate(classLoader: ClassLoader, className: String): Fragment {
  try {
    val cls: Class<out Fragment> = loadFragmentClass(classLoader, className)
    return cls.getConstructor().newInstance()
  } catch (java.lang.InstantiationException e) {
    …
  }
} LayoutId in the constructor Let's remember how we learned to work with fragments. We create a class, create a markup file, and inflate it in : onCreateView() override fun onCreateView(
  inflater: LayoutInflater,
  container: ViewGroup?,
  savedInstanceState: Bundle?
): View? = inflater.inflate(R.layout.fragment_example, container, false) We've typed these familiar strings hundreds of times, but in version 1.1.0 of , the folks at Google have decided they won't take it anymore. They added a second constructor to fragments that take as input, so you no longer need to override . Fragments @LayoutRes onCreateView() class ExampleFragment : Fragment(R.layout.fragment_example) And under the hood, the same boilerplate works: constructor(@LayoutRes contentLayoutId: Int) : this() {
  mContentLayoutId = contentLayoutId
}

open fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?) : View? {
  if (mContentLayoutId != 0) {
    return inflater.inflate(mContentLayoutId, container, false)
  }
  return null;
} The less code we have to write, the better. If suddenly you have previously initialized the View in , it is more correct to use a special callback called immediately after . onCreateView() onViewCreated() onCreateView() override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
   button.setOnClickListener {
      // do something
   }
   // some view initialization
} Summary This article looked at the features and new features of creating Fragments and how you can pass LayoutId in the Fragment constructor. In the next part of the article, we will look at animations during the transition and closing of the Fragment.

Understanding Fragments in Android: Part 2

Stories, News & Mentions about RLTY

Rlty’s Stories on HackerNoon