Data Retrieved From State Not Display In Flatlist

In the Apollo group, we're passionate about doing for data loading what React Native is doing for native UI improvement. We need to allow product developers to spend much less time managing data and extra time building a great utility. There are two major props you want to find out about in a FlatList and that's data and renderItem. Here, we register listeners to keyboardDidShow and keyboardDidHide occasions to maintain present keyboard status as astate of the part. The listeners are registered when the element gets mounted. Since we by no means remove these listeners, they'll nonetheless receive keyboard occasions even after component will get unmounted. At the identical time, Keyboard module has to keep the list of lively listeners in world scope — in our case, it will retain the arrow capabilities we pass to addListener method. This easy mistake can lead to very large areas of memory left retained accidentally. Styles that can be utilized to a FlatList element is finished by the prop contentContainerStyle that accepts the worth of Stylesheet object. The reason to use FlatList is that it's performance effective. Of course, you can use ScrollView but it renders gadgets from reminiscence, which is not a really performant effective approach to display a prolonged list of items. ScrollView is a wrapper on the View part that gives the consumer interface for scrollable lists inside a React Native app. For now, allow us to hook up the business logic to display an inventory of items as nicely as the flexibility to add a model new item utilizing the modal screen you have arrange within the previous steps. Note that we've specified an extra keyExtractor prop to the FlatList. This allows us to specify a operate to be used for extracting the important thing for each list item.

As you've realized within the previous tutorial, a unique key's wanted for each merchandise within the list. This is added as one of many properties of the exercise object when an exercise is created. I'm not sure how much I can refactor this as it's purely primarily based on what is being rendered, and no function is inflicting points. I don't want/can't change what is displayed by which screens, so I need to see another method. I observed this in other RN apps too, so I'm not sure of what one of the best approach is. Now that I perceive it nonetheless, I am optimistic that there is an approach that can clear up it. Usually, it's quite troublesome to inform if the app is leaking — particularly that typically the leaks are so small that it is just about inconceivable to note. The greatest strategy is to investigate a workflow inside your app that you'd expect to be memory impartial, i.e., a sequence of steps that ought to not result in any new objects being retained. For example, navigating to a new screen and going back to the previous, or adding and removing items from a listing are each situations that generally shouldn't increase reminiscence usage. If such a workflow leads to leaking, you should notice your app's memory consumption to grow after you repeat it a number of times. The snippet above makes use of the native base library to create a managed input type to let the consumer add a brand new item to the todo list. Since the Input component from Native Base is based on the React Native's TextInput, you should use all of the props which are out there to TextInput. These operations are going to communicate with the realtime data on the system.

You are going to make use of objects as a substitute of an array to store this stuff. AsyncStorage operates on key-value pairs and not arrays. Each object is going to be identified via a novel ID. In order to generate distinctive IDs, you'll use a module referred to as uuid which was put in earlier. Create a Floating button 🔗Inside the components/FloatingButton.js file, you'll create a floating action button or in mobile growth, generally generally recognized as FABs. These kind of buttons are sometimes distinguished by a circled icon floating above the UI in a set position. If you may be an Android user or have seen a cell app following any materials design specification, you might have observed them. Next, let us outline an preliminary state with two empty strings. They are going to be used to avoid wasting the worth of the user enter after which retrieve the value to display it on the app display screen. After defining the initial state, there could be going to be a lifecycle methodology that is going to load the info when the applying begins for the first time or the App part renders. In this project, we are going to be taught totally different strategies for API calls including fetch() methodology and Axios method supplied by react-native. We may also see the completely different configurations and properties of these methods utilizing fetch and axiosin react native purposes.

It is necessary to move the Key to every Element with on this map method. Keys assist React determine which items have changed, are added, or are eliminated. The best method to pick a secret is to make use of a string that uniquely identifies a list item amongst its siblings. It's essential to grasp the distinction betweendoc['my_field'].value and params['_source']['my_field']. The first, using the doc keyword, will trigger the phrases for that area to be loaded to reminiscence , which will lead to sooner execution, but extra memory consumption. Also, the doc[...] notation only permits for simple valued fields (you can't return a json object from it) and makes sense only for non-analyzed or single term primarily based fields. However, utilizing doc remains to be the beneficial approach to access values from the doc, if in any respect potential, as a result of _source should be loaded and parsed each time it's used. Since this is the primary time that we're using the state, I'll clarify to you briefly what state is, and how it's used in React Native. The "state" is used to retailer data that can be modified over time. This change could be a results of a person interplay (e.g. when a person faucets on a button), or the execution of another code within the app. The sort of information usually stored within the state are those that affect what's being rendered in the UI. For instance, when you have a button which modifications its label each time it's pressed. You want to put the label for that button within the state. That method you can simply update it each time the button is pressed. Lets see the whole supply code that helps to display error message "No Data Available", when FlatList view is empty in react native utility. In Above Code snipped I even have use List View and Grid View display of FlatList items. In Grid View use 2 columns and list View use 1 column.

Firstly, data prop is an array of information that is used because the source for creating the list. And, therenderItemis a callback perform that can accept the person item from thedataprop and render a element for it. You no longer need to format the information — as an alternative, you probably can cross an array and begin rendering immediately. The data prop is an array of data that's used because the source for creating the list. The renderItem is a callback perform that can settle for the person item from the information prop and render a element for it. A FlatList accepts an array of data, and shows the leads to a performance friendly scrollable list. By integrating a realtime listener with the FlatList, each time data adjustments without our database it's going to routinely and efficiently update on our software. This is the time to start utilizing them so as to construct the offline todo list app. Before starting with the event of the app, create the next folders and files inside them. This will give a construction to handle the app later or if you wish to extend by including new options to it. Most of the code above is identical as the previous one. The only distinction is in the object handed as the navigation params. From the code in the app/screens/Routines.js file earlier, we now have passed the key and name because the navigation params. So we're mainly passing the same thing to the next page which is the Create Exercise page. In this tutorial we'll explain tips on how to display image in react native software utilizing HTTP URL .

In this tutorial, we will explain the way to get image from native resource folder and display the picture in react native application . I adjusted the above code for me so as to make it work correctly. One incorporates full list of objects and second accommodates only rendered list of objects which is altering upon search. TheonRefreshis a callback prop that calls the operate when therefreshingprop is about totrue. This operate should be responsible for loading new data and updating the list gadgets within the React Flatlist element. Still, it provides a performance factor to it, like solely rendering the objects seen on the display, and only updating the objects which were changed. The React Flatlist component works great for giant items of information that might change over time. The onRefresh is a callback prop that calls the function when the refreshing prop is ready to true. This perform should be liable for loading new data and updating the list items in the FlatList element. We seen that when components get unmounted in some instances, they keep retained in React's inner data structures . We haven't had sufficient time to dive to the underside of this problem but observed that eliminated part keep referenced like that solely quickly. The simplest way that we discovered to get them cleared was to set off the setState for any part within the tree. Let us begin by modifying onPressFab methodology inside the HomeScreen.js. The parameter newTask passed to the addTodo function is going to be the object. Using if assertion, there is a verify whether the todo item being entered is not empty. This.setState uses a callback method that has entry to prevState object. It provides any todo item that has been previously added to the list.

First, let us start by importing all components and custom elements required so as to build the applying inside HomeScreen.js file. The final method that you are going to make the most of from the AsyncStorage API is called clear(). It just isn't recommended to use this method directly if you want to delete only a selected merchandise from the storage. For that, there are methods like removeItem or multiRemove obtainable by the API. You can learn extra about them in the official documentation right here or later when building the Todolist application. Start by importing the necessary elements from React Native API. The most essential one here is AsyncStorage. Since you will store only one value in the meanwhile, there's solely the requirement for one key. React Native functions render utilizing actual mobile UI elements, not web-views, and can appear and feel like some other native cellular utility. React Native additionally exposes JavaScript interfaces for platform APIs, so your React Native apps can access platform features like the phone digicam, or the user's location. Facebook, Palantir, TaskRabbit etc are already using it in manufacturing for user-facing applications.

You can not use the docvalue_fields parameter to retrieve doc values for nested objects. If you specify a nested object, the search returns an empty array () for the sphere. To entry nested fields, use theinner_hits parameter's docvalue_fieldsproperty. Widgets are the basic building blocks of an app's person interface. You compose widgets right into a hierarchy, called a widget tree. Each widget nests inside a father or mother widget and inherits properties from its mother or father. Before we proceed with the following bit of code, I'd like to provide a brief overview of component lifecycle strategies on React. One such method is the componentDidMount which we just used. This methodology known as once the part (and all of its sub-components) is rendered on the display. There are also lifecycle methods which are executed right earlier than something occurs. While something that has a did prefix is executed after one thing occurs. Instead of rendering a number of nested components per list merchandise, render a single one which may be very easy and dump, that simply render the received props. While constructing apps, you'll come across some lists; these can be a list of contacts, users, actions, and so on. But, displaying giant data units or a protracted list just isn't that performant. That's where React Flatlist element comes into the picture. It's a simple method to make an environment friendly scrolling list of knowledge.

Not solely is it efficient however it's obtained an incredibly easy API to work with. If you've used or are conversant in the ListView part it's very related, simply higher in each way. 😀 No longer do you need to format the data — you can simply cross it an array of knowledge and get to rendering instantly. The extra complex your parts are, the slower they'll render. Try to keep away from a lot of logic and nesting in your list objects. If you might be reusing this list item component so much in your app, create a component only on your big lists and make them with as little logic and nesting as possible. The FlatList part works nice for large items of information that might change over time. That's where React Native's FlatList part comes into the image. As for FlatList, probably the most buggy part in all React Native, I highly suggest you not to speak about FlatList as a "rock solid" element. I was excepting a deep dive into the part itself and how to keep away from no much less than the rendering points, the pictures not loading throughout the FlatList items etc.. Just a really beginner's guide, which is nice for newbies, but change the title, it's totally misleading. When rendering a listing of components, you must always use a part based mostly on a VirtualizedList, similar to a FlatList or a SectionList. I can bear in mind one case the place we had this unhealthy pattern, observed it and solved it. Basically this occurred when we mixed the used of RenderProps and High Order Components.

As Apollo person, we use in most places Apollo Query Component to fetch data from our endpoint. Because our code type is to make use of recompose when attainable, the initial implementation was wrapping the Apollo Query element in a fromRenderProps HOC. This works nice for all query where you don't want dynamic variables, but failed otherwise, as there isn't any way to give particular props to your render props element. The first one was to just accept to not use Recompose HOC here, and just do a daily Component utilizing a more classical implementation. The second one, that we select, was to modify to Apollo graphQL HOC, which is documented to match our usage. Probably the most popular advices round React performances issues the use or not of PureComponent (and/or React.memo()). Long story brief, ineffective re-render in React is often not an issue but can become one on complicated software. PureComponent is a way to stop a element to re-render when his props didn't modified. More exactly it implements it implements shouldComponentUpdate by doing a shallow comparability of props. I am writing code to launch different purposes from my react native utility for android and ios. I have tried lot of things but I can't nonetheless found out what it's since it really works properly in debug mode. Next, let us modify the render method to realize the specified outcome. Inside the render technique, you are going to add a model new UI factor from Native base called Segment. This is going to display two buttons, every of which could be activated when pressed. The activation of each this button is decided by the worth of the state property filter. By passing an object with to add a model new merchandise to the list you will make the most of one other advantage that a glossy library react-navigation offers. Deleting a Todolist Item 🔗Similar to the addTodo method, you are going to add another method known as deleteTodo.

Open Fragment From Activity Kotlin

Nice article, but in my opinion the biggest headache on Android is not the Activity vs Fragment vs Views dispute but the general architecture of an app. The first thing one would do is to separate your logic and ui. Although they do involve writing a bit of boilerplate code, in most use cases using Views results in a simpler application lifecycle. When it comes to portability issues, there are basically none with this approach, since you could always wrap your View - and actually that's what Fragments really are. That is just a preference though - View, as I perceive it, could mean the basic UI building block, but it has to be referred to as an idea, that fragments could implement too. The most important thing therefore is to give the view layer an abstraction that can be easily adapted to changes.

Fragment can has it's own menu, the fragment menu items are also displayed in android application action bar. This article will show you how to add menu items in android fragment and how to use fragment menu items with activity menu items. TL;DR You can use a target fragment to pass data between fragments in the same way you would use startActivityForResult() and onActivityResult(). You just need to be aware of how add and replace transactions affect the fragment lifecycles, and how to handle the result in each case. This component tracks the fragments in all aspects of their lifecycle.

This includes when they are initialized, started, created, resumed, and destroyed. A LifecycleObserver allows the developer to detect when a specific fragment is active. For instance, an app can display a Snackbar or Toast message. According to the Android documentation, a fragment is a part of applications user interface that is bound to an activity. Fragments have their lifecycle and layouts or UI components. Fragments help enrich your UI design, pass data between different screens, and adapt to different device configurations.

When the user clicks on the button two things are happening. First, we check to see if FRAGMENT_2 already exists and if it doesn't, we create a new instance of it in order to load it into the activity. Second, we take the text that we entered in the EditText and pass it to the second fragment . Since we are not passing large amounts of data we can use the setArguments() method or the arguments property. If we had large amounts of data to pass to our fragments we should have used a ViewModel.

This is the "top-level" fragment, showing a list of items that the user can pick. Upon picking an item, it takes care of displaying the data to the user as appropriate based on the current UI layout. Displays a list of items that are managed by an adapter similar to ListActivity. It provides several methods for managing a list view, such as the onListItemClick() callback to handle click events. The fragment uses a helper function to show details of a selected item. You can also review the FragmentTransaction to take a closer look at what modifications can be made at run-time through the manager.

In this step, we need to determine how users will navigate through the application. Go to the new destination icon and add the questionFragment as the starting point. All we need to do is null check drawerLayout before setting up drawer view and menu icon before we try to close the drawer. If Android decides to use our layout/activity_main.xml, then the view hierarchy will contain a view with IDdrawer_layout.

If Android decides to use layout-sw600dp/activity_main.xml, then the view hierarchy will NOT contain a view with that ID. In other words, we are able to use the presence of drawerLayout as an indication of whether we're on a large screen or not. The fragment saves its current dynamic state, so it can later be reconstructed in a new instance of its process is restarted.

If a new instance of the fragment later needs to be created, the data you place in the Bundle here will be available in the Bundle given to onCreate, onCreateView, and onActivityCreated. In the code the new fragment restores the state in onActivityCreated(). In portrait mode the application will replace the existing titles fragment with the details fragment if the user taps on one of the names in the list view . We will come back to discuss how this is done in the code in a moment.

Essentially there are two activities and two different fragments used to implement this when the code runs in portrait mode; these activities are FragmentLayout and DetailsActivity. This technique has the advantage of not having to deal with activities and only define all the UI in the Fragments. To the unfamiliar, the Navigation Component is not another UI class that you place instead of a layout for your activity/fragment. Think of it like a map, where instead of continents, you have your fragments, and you will need directions to get from continent to continent.

It presents your fragments and the connections between them in a top down manner. In this article, we will go over the main aspects of this component and learn how we can integrate it into our applications. The NavHost fragment acts as a container or host for all the fragments. In other words, any fragment that is displayed to the user is hosted in this NavHost container. The NavHost fragment is usually created in the primary activity .

In our case, the primary activity layout is the activity_main.xml. The guide for Integration with Existing Apps details how to integrate a full-screen React Native app into an existing Android app as an Activity. To use React Native components within Fragments in an existing app requires some additional setup. The benefit of this is that it allows for a native app to integrate React Native components alongside native fragments in an Activity. In theonCreateView()method the fragment creates its user interface. Here you can inflate a layout via theinflate()method call of theInflatorobject passed as a parameter to this method.

Use one activity, which displays two fragments for tablets and on handset devices. In this case change at runtime the fragments displayed by the activity whenever necessary. In this scenario you typically define instances of the FrameLayout class as placeholder in your layout and add the fragments at runtime to them. A lot has changed over the last couple of years when it comes to our development approach in Android. Without wasting too much of your time, let's get into how we can start another fragment for results. This example demonstrates how to send data from one Fragment to another using Kotlin.

Step 1 − Create a new project in Android Studio, go to File ⇉ New Project and fill all required details to create a new project. Step 2 − Add the following code to res/layout/activity_main. In Android, a fragment is a portion of the user interface that can be used again and again. Fragment manages its own layout and has its own life cycle. Since fragment is a small portion of the bigger user interface, it can only be initialized inside an activity or another fragment. So if we wish to display any type of resources, such as a string, or an image inside the fragment, we will need to declare them in the activity and then pass it to the fragment.

So in this article, we will show you how you can pass data from an Activity to the Fragment. Where i need to show drawer i use fragments and where i need to show back or up button i use parent activtiy concept. But it was a good article i learned from it that we can apply a listener on fragments for delivering results to previous fragment.

Of course this navigation diagram is a fairly a simplistic approach. In this post, we'll learn about full screen dialog fragment Android. For better understanding, I will create a sample app that app contains full screen dialog in Android. Additionally, we'll learn how to pass data dialog to fragment or also.

In this tutorial, we have learned how to add fragments and navigate across different screens. You are, therefore, ready to work on other productive applications. Make sure you run yarn to install your react-native dependencies and run yarn native to start the metro bundler. Run your android app in Android Studio and it should load the JavaScript code from the development server and display it in your React Native Fragment in the Activity. There are a fewways to accomplishthis "always open" behavior on tablets by using DrawerLayout.LOCK_MODE_LOCKED_OPEN, but I found them a bit hacky and inelegant.

Additionally, by implementing CodePath's example, too much of the view logic would live in the hosted activity, so I set out to see if I could use fragments to solve this problem. Basically, we will have a master fragment that will be used for the drawer view and a detail fragment for the main view. We'll then reuse these fragments in a classic master/detail arrangement on tablets. In addition to that you can use the setRetainState method call on the fragment. This retains the fragment instances between configuration changes.

It only works if the fragments are not added to the backstack. For purposes of demonstrating the basic usage of the navigation architecture component I will be creating two simple fragments to be shown in this app, Fragment1 and Fragment2. They will both contain a simple TextView with the text "Fragment 1" and "Fragment 2" correspondingly. Fragment1 will also contain a button which will be used later in the tutorial to navigate to Fragment2. In Android, Fragment is a part of an activity which enable more modular activity design. It will not be wrong if we say a fragment is a kind of sub-activity.

It represents a behaviour or a portion of user interface in an Activity. We can combine multiple Fragments in Single Activity to build a multi panel UI and reuse a Fragment in multiple Activities. We always need to embed Fragment in an activity and the fragment lifecycle is directly affected by the host activity's lifecycle.

A bundle maps string keys to values and it is used to pass data between activities, fragments and other application components. In the second activity I have two big buttons, each taking up half of the screen horizontally. Each button is suppose to open/start a fragment, button one starts fragment one, and, likewise, button two starts fragment two.

The fragment lifecycle ensures that onCreateView() to build the layout for the fragment. It builds the fragment with a textview -- text.setText(Shakespeare.DIALOGUE[getShownIndex()]) -- and attaches it to a scroller and returns the view which is drawn. Once the changes are made to the FragmentTransaction, commit() is called for the changes to take effect. At any time while your activity is running, you can add fragments to your activity layout. You simply need to specify a ViewGroup in which to place the fragment.

To make fragment transactions in your activity , you must use APIs from FragmentTransaction. You can get an instance of FragmentTransaction from your activity as shown below. The end of this thread is the drawing of the details fragment by the new activity as shown below.

Assume in the path through the onCreate() for the activity that its the first time through the application/activity running. We first create a new fragment , set the index for the item selected and the we use the programmatic approach to adding the fragment. The second way is by adding the fragment dynamically in Java using the FragmentManager. The FragmentManager class and the FragmentTransaction class allow you to add, remove and replace fragments in the layout of your activity at runtime. Instrumentation test cases require device or emulation, and they are slow, but we can run them on different devices simultaneously.

However, often you can face a situation when all instrumentation test cases are written in the "End to End" approach. It means we always start the test from the initial screen of or application, like the Login or Splash screen. As a result, our End-To-End test cases are slow because we should spend some time on the navigation to the required screen, and only after it, we can start to verify the screen. When you login first time using a Social Login button, we collect your account public profile information shared by Social Login provider, based on your privacy settings. We also get your email address to automatically create an account for you in our website. Once your account is created, you'll be logged-in to this account.

Really interesting pattern in paper, but as Ryan said, when the projects become large enough the main Activity that holds the Fragments references transforms in something like a 'God' class. The mess that it's caused by it and its maintainability cost, for me, its just not worth it. Navigation in mobile applications, when done right, can have tremendous positive impact on overall user experience. Android offers application developers multiple ways of implementing navigation in their application.

However, not all navigation patterns are created equal. In this article, Toptal engineer Becze Szabolcs shows us how to implement fragment-based navigation and how it stacks up against Android's traditional navigation philosophy. OnDestroyView() — This method called when the view and related resources created in onCreateView() are removed from the activity's view hierarchy and destroyed.

A navigation graph outlines all the actions, destinations, and logical connections in an application. It helps you determine how the user will navigate through the application. Back stack allows users to navigate back to the previous activity or fragment. In Activities, back stack is implemented automatically. In fragments, back stack needs to be declared manually using the addToBackStack method.

If you want to add the transaction to the backstack of Android, you use the addToBackStack() method. This adds the action to the history stack of the activity and allows the user to revert this change via the back button. The FragmentManager class allows you to add, remove and replace fragments in the layout of your activity. It can accessed in an activity via the getFragmentManager() method. Activity and fragment instance have been created as well as the view hierarchy of the activity.

At this point, view can be accessed with thefindViewById()method. Now that these fragments have been created we will now proceed to add them as destinations to the navigation graph using the Navigation Editor inside Android Studio. If we run the app now it will crash as we have not yet added any fragments as destinations to the navigation graph. That means the app will not know what to show inside the NavHostFragment window. We will cover the creation of fragments and adding them to the navigation graph in the next step.

Hii everyone in this Android Article we are discussing on DialogFragment. Hare we can learn How To open a DialogFragment in activity Android tutorial. We are Create a Dialog fragment in Dialog we can create a user form. This android dialog fragment uses in Activity and opens on button click. So create two fragments by right click on your package folder and create classes and name them as FirstFragment and SecondFragment and add the following code respectively. In this step we open MainActivity and add the code for initiate the Button's.

Urdu Vs Punjabi In Pakistan

Punjabi language, Punjabi also spelled Panjabi, one of the most widely spoken Indo-Aryan languages. The old British spelling "Punjabi" remains in more common general usage than the academically precise "Panjabi." In the early 21st century there were about 30 million speakers of Punjabi in India. It is the official language of the Indian state of Punjab and is one of the languages recognized by the Indian constitution. In Pakistan Punjabi is spoken by some 70 million speakers, mostly in Punjab province, but official status at both the national and the provincial level is reserved for Urdu.

In September 2015, a case was filed in Supreme Court of Pakistan against Government of Punjab, Pakistan as it did not take any step to implement the Punjabi language in the province. Additionally, several thousand Punjabis gather in Lahore every year on International Mother Language Day. Thinktanks, political organisations, cultural projects, and individuals also demand authorities at the national and provincial level to promote the use of the language in the public and official spheres. When Pakistan was created in 1947, despite Punjabi being the majority language in West Pakistan and Bengali the majority in East Pakistan and Pakistan as whole, English and Urdu were chosen as the national languages. The selection of Urdu was due to its association with South Asian Muslim nationalism and because the leaders of the new nation wanted a unifying national language instead of promoting one ethnic group's language over another.

Broadcasting in Punjabi language by Pakistan Broadcasting Corporation decreased on TV and radio after 1947. Article 251 of the Constitution of Pakistan declares that these two languages would be the only official languages at the national level, while provincial governments would be allowed to make provisions for the use of other languages. However, in the 1950s the constitution was amended to include the Bengali language. Eventually, Punjabi was granted status as a provincial language in Punjab Province, while the Sindhi language was given official status in 1972 after 1972 Language violence in Sindh.

Punjab is the most densely populated province of Pakistan and therefore a majority of the population lives there and speaks Punjabi. I have never in my entire life seen any Sindhi, any Balochi, or any Pashtun criticizing Urdu or its native speakers. We cannot make Punjabi the national language just because majority of the population speaks it.

Regarding patriotism, I want to ask the author as to why people in Punjab including Lahore and Islamabad judge you because of your non ability to speak fluent Punjabi. Is it true that people belonging to the Urdu speaking community of Sindhi community or Pashtun are not high class Pakistanis like Punjabis. Please stop creating hatred among people on the basis of language. Although Punjabi was the majority language in West Pakistan when Pakistan was created in 1947, and Bengali the majority in East Pakistan and Pakistan as a whole, English and Urdu were chosen as the official languages. Eventually, Punjabi was granted status as a provincial language in Punjab Province. In India, Punjabi is one of the 22 scheduled languages of India.

It is the first official language of the Indian State of Punjab. Punjabi also has second language official status in Delhi along with Urdu, and in Haryana. In Pakistan, no regional ethnic language has been granted official status at the national level, and as such Punjabi is not an official language at the national level, even though it is the most spoken language in Pakistan.

It is, however, the official provincial language of Punjab, Pakistan, the second largest and the most populous province of Pakistan as well as in Islamabad Capital Territory. The only two official languages in Pakistan are Urdu and English. Urdu belongs to the Indo-Iranian language family, which is spread all across Central Asia, South, West, and Southeast Asia. It is spoken by close to 250 million native speakers and is learned by over 100 million more as a second language. It is the official language of Pakistan and one of two official languages in India.

Urdu as a language evolved during the last days of the Mughal rule in India. Persian was the official language of the Mughal emperors along with Turkic and Arabic. At that time, the northern part of India was the centre of rule and knowledge, particularly Delhi and its surrounding areas, including today's Bihar and Uttar Pradesh. Due to the interaction of local population and the ruling Persian-Turkic-speaking Muslim elite, a new language evolved and was known as Hindustani. So, Urdu became one of the signs of era of prosperity and power of the Muslims in this sub-continent.

In India it is the official language of Punjab state and one of the 15 official languages recognized by the Indian constitution. It is also spoken in the neighboring states of Haryana and Himachal Pradesh. In addition about 25 percent of the people living in the New Delhi metropolitan area speak punjabi in everyday life. All told, there are about 25 million speakers in India. Although Urdu is the official national language, it is spoken as a native tongue by only 8 percent of the population.

People who speak Urdu as their native language generally identify themselves as muhajirs. A large number of people from educated backgrounds speak Urdu, as opposed to their natal languages, in their homes, usually to help their children master it. Despite Punjabi's rich literary history, it was not until 1947 that it would be recognised as an official language. Previous governments in the area of the Punjab had favoured Persian, Hindustani, or even earlier standardised versions of local registers as the language of the court or government.

After the annexation of the Sikh Empire by the British East India Company following the Second Anglo-Sikh War in 1849, the British policy of establishing a uniform language for administration was expanded into the Punjab. The British Empire employed Urdu in its administration of North-Central and Northwestern India, while in the North-East of India, Bengali language was used as the language of administration. Despite its lack of official sanction, the Punjabi language continued to flourish as an instrument of cultural production, with rich literary traditions continuing until modern times. The Sikh religion, with its Gurmukhi script, played a special role in standardising and providing education in the language via Gurdwaras, while writers of all religions continued to produce poetry, prose, and literature in the language.

Punjabi is the provincial language of Punjab province in Pakistan and it has not given official status at national level. In India, Punjabi is spoken by 31.1 million people and has official status in the state of Punjab. The language is spoken among a significant overseas diaspora, particularly in Canada, the United States and the United Kingdom. Punjabi is a language spoken by millions of people in over ten countries, mainly in the northern region of South Asia.

It is one of the national languages of India and Afghanistan as well as, to a lesser extent, Pakistan and Nepal. The first evidence of Punjabi dates back to the 5th century BC, making it one of the oldest living languages on Earth. Almost half of Punjabis speak their native language, most notably those who live in India, but there are still plenty left who speak nothing else but Punjabi. Punjabi belongs to the Indo-Aryan language family, which is spread all across India, Pakistan, and Southeast Asia. It is spoken by close to 90 million native speakers and is learned by over 10 million more as a second language. It is one of the 22 official languages in Pakistan and one of the official languages in India, as well as having a large number of native speakers in Bangladesh and Nepal.

SOON after the partition of the subcontinent into India and Pakistan, especially after India had taken Hindi as the official language, central leaders of Pakistan wanted Urdu to be the sole state language of entire Pakistan. This is a decision which had been strongly opposed by the people of East Pakistan. With the utmost surprise of the history of the language movement, Urdu itself has never been the most widely spoken language of Pakistan till now.

During the movement, it was the language of only 7 per cent of the total population of Pakistan while Bangla accounted for 54 per cent.The mother tongue of most of the West Pakistanis were Panjabi, Pashtu, Sindhi, Balochi and so on. I am willing to accept this novel theory because I firmly believe it has been formulated with the noble motive to enhance the worth of our national language which badly needs such boosts. However, the only problem with it is that it is next to impossible to find any facts or historical evidence to substantiate it. If you consult the latest census report, you will find out that only less than 5 per cent of people living in the Punjab use Urdu as their mother tongue.

Now the mother tongue of a territory is that which is its 'natural' language and is spoken by the vast majority of people inhabiting it. This is the only definition of an area's mother tongue and it flies in the face of the claim about Urdu being the mother tongue of the Punjab. Saraiki (Sarā'īkī, also spelt Siraiki, or less often Seraiki) is an Indo-Aryan language of the Lahnda group, spoken in the south-western half of the province of Punjab.

Saraiki is to a high degree mutually intelligible with Standard Punjabi and shares with it a large portion of its vocabulary and morphology. At the same time in its phonology it is radically different , and has important grammatical features in common with the Sindhi language spoken to the south. Saraiki is the first language of about 20 million people in Pakistan, its territory ranges across southern Punjab, parts of southern Khyber Pakhtunkhwa, and some border regions of northern Sindh and eastern Balochistan.

Karachi is one of the most Pashto speaking cities in the world. Pashto is also widely spoken in neighboring Afghanistan where it has official language status. It is also proposed to be the co-official language along with English. The country also has several regional languages, including Punjabi, Saraiki, Pashto, Sindhi, Balochi, Gujari, Kashmiri, Hindko, Brahui, Shina, Balti, Khowar, Dhatki, Haryanvi, Marwari, Wakhi and Burushaski. Four of these are provincial languages – Punjabi, Pashto, Sindhi and Balochi.

Urdu is a mixture of Persian language and Arabic used as the main languages of Muslim culture. It is considered by many to be a genius linguistic masterpiece. With its rich vocabulary, it has been able to adapt over time to the regional languages and culture of South Asia. The Urdu language was created in 1844 by a Muslim scholar, Mir Ameer Ali Khan Shere Ali, who wanted to make the Arabic script workable for the different languages of India with an aim for unification.

This resulted in creating a new alphabet from scratch from English letters. Urdu is predominantly a spoken language with an emphasis on written literature. In Pakistan, it is used as a language of government, education, and culture. While in India, it is mainly used for cultural purposes.

The official language of Pakistan is Urdu, but most public officials, people, and others in Pakistan also speak English; English is referred to as the informal official language of Pakistan. Urdu was created by combining the languages of early invaders and settlers, including Arabic, Persian, and Turkish. The spoken form of Urdu is the same as that of Hindi but it is written in a different script than Hindi.

Is Urdu Pakistani Or Indian Pakistan is in South Asia and is 339,697 square miles in area. It was created from what had been the northwest side of India. All of the country except the southern portion is landlocked, with Afghanistan to the northwest, Jammu and Kashmir to the northeast, India to the east and southeast, and Iran to the west. In the southern portion, along the shores of the city of Karachi, which was the original capital when the nation was formed in l947, is the Arabian Sea. Most of the northern section of the country consists of mountains and also the famous Khyber Pass, whose history goes back several thousand years. It is in this northern section where most of the ancient tribes still live and where many ancient tribal cultures and customs still exist.

Zulfikar Ali Bhutto's cousin Mumtaz Bhutto led the provincial government in Sindh then. With overt support from him, the provincial assembly passed the Sindhi Language Bill, 1972, on July 7 that year, declaring Sindhi as the official language of the province. Resistance to the imposition of Sindhi from the Urdu-speaking residents of the province – most of whom were muhajir from north India – was both swift and severe. It resulted in deadly riots across urban centres in Sindh. Persian has influenced Urdu immensly, and is still appreciated as a literary and prestigious language among the educated elite, espeiclly in fields of music and art.

In fact, Pakistan's national anthem - the Qaumi Tarana - is written in a highly Persianized form of Urdu that almosts sounds as if the anthem were actually written in Persian. South Asian Muslims have long felt that Urdu symbolizes their shared identity. It has served as a link among educated Muslims and was stressed in the Pakistan independence movement. However, because many of the elite were fluent in English, English became the de facto national language. The push to elevate Urdu was unpopular in East Pakistan, where most of the population speaks Bengali and identifies with its literary heritage.

Today Mulayam Singh Yadav made a statement saying that members of parliament from non-Hindi speaking states should learn to speak Hindi instead of using English. He has been roundly criticized by politicians from different parts of the country, as well as members of civil society. I'm thankful that Hindi doesn't stand for anything more than a lingua franca for 40 per cent of India, and is not misrepresented as a symbol of patriotism or Indian-ness. Other languages were cultivated for most kinds of writing, including Persian under the Mughal Empire, then Urdu during the British period and, in Pakistan, continuing to the present day. In most other Indo-Aryan-speaking areas of South Asia, the modern period saw overlapping local dialects being grouped into strictly defined provincial languages, but this process has taken much longer to happen in Punjab.

There were earlier just a handful of intellectuals, who were largely ignored by the media and those in power. But over the years, the protest has grown in size and is now accompanied by a celebration of Punjabi culture with dhol, music and dance. The Punjabi Adabi Board, a Lahore-based literary organisation that promotes literature in Punjabi, has been at the forefront of this movement. As British schools started springing up around Punjab, Urdu and English became the medium of instruction. Punjabi was thought to be too barbarous a language compared to Urdu. Slowly, as indigenous schools popular throughout the Lahore Durbar and spread across the province were dismantled, a new breed of students emerged, divorced from the educational experiences of their predecessors.

Whereas education earlier was a communal experience reinforced by family members at home, new divisions now emerged between children who were educated and parents who were not. These divisions were often understood as a differentiation between those who were civilised and those who were not. An entire civilisation, culture, history, people, literature, language, experience was stigmatised as Punjab raced towards modernity.

English is a co-official language of Pakistan and is widely used in the executive, legislative and judicial branches as well as to some extent in the officer ranks of Pakistan's armed forces. Pakistan's Constitution and laws were written in English and are now being re-written in the local languages. It is also widely used in schools, colleges and universities as a medium of instruction.

English is seen as the language of upward mobility, and its use is becoming more prevalent in upper social circles, where it is often spoken alongside native Pakistani languages. Turkic languages were used by the ruling Turco-Mongols such as the Mughals and earlier Sultans of the subcontinent. The autobiography of Mughal emperor Babur, Tuzk Babari was also written in Turkish. After returning from exile in Safavid Persia in 1555, Mughal emperor Humayun further introduced Persian language and culture in the court and government. The Chaghatai language, in which Babur had written his memoirs, disappeared almost entirely from the culture of the courtly elite, and Mughal emperor Akbar could not speak it. Later in life, Humayun himself is said to have spoken in Persian verse more often than not.

The religious revivals of the 19th century have to be examined in the wider context of the anti-colonial freedom movement of the 20th century. The Indian National Congress claimed to represent all Indians irrespective of religion. It declared Hindustani, the common vernacular of north India with the Devanagari and Persian scripts, as the national language of a future independent, united India. The All-India Muslim League rejected the INC's claim to represent all Indians. Instead, the Muslim League, as it has come to be known, claimed to represent all Indian Muslims.